unit CMath;

{ ------------------------- } interface { ----------------------- }

type
  Complex = object
    Re, Im: real;
    procedure Inic(tRe, tIm: real);
    function aStr(C, D: integer): string;
    procedure Leer;
    procedure Sumar(C: Complex);
    procedure Restar(C: Complex);
    procedure Mult(C: Complex);
    procedure Divid(C: Complex);
    function Modulo: real;
    function Angulo: real;
    procedure Rotar(Ang: real);
    procedure aRect;
    procedure aPolar;
  end;

function aGrados(A: real): real;
function aRad(A: real): real;

{ ----------------------- } implementation { -------------------- }

function aGrados(A: real): real;
begin
  aGrados := A * 180.0/Pi;
end;

function aRad(A: real): real;
begin
  aRad := A * Pi/180.0;
end;

procedure Complex.Inic(tRe, tIm: real);
begin
  Re := tRe; Im := tIm;
end;

function Complex.aStr(C, D: integer): string;
var
  S1, S2: string;
begin
  str(Re:C:D, S1);
  str(abs(Im):C:D, S2);
  if Im < 0.0 then
    aStr := S1 + ' -' + S2 + 'j'
  else
    aStr := S1 + ' +' + S2 + 'j';
end;

procedure Complex.Leer;
var
  Lin: string[80];
  Err: integer;

  procedure Split(Donde: char);
  var P: integer;
  begin
    P := pos(Donde, Lin);
    val(copy(Lin, 1, P-1), Re, Err);
    if Err <> 0 then exit;
    val(copy(Lin, P+1, length(Lin)-P), Im, Err);
    if Err <> 0 then exit;
    if Donde = '<' then begin
      Im := aRad(Im);
      aRect;
    end;
  end;

  begin
    readln(Lin);
    if pos(',', Lin) <> 0 then Split(',')
    else
      if pos(' ', Lin) <> 0 then Split(' ')
      else
        if pos('<', Lin) <> 0 then Split('<')
        else begin
          Lin := Lin + ',0';
          Split(',');
        end;
    if Err <> 0 then begin
      Re := 0.0; Im := 0.0;
    end;
  end;

procedure Complex.Sumar(C: Complex);
begin
  Re := Re + C.Re;
  Im := Im + C.Im;
end;

procedure Complex.Restar(C: Complex);
begin
  Re := Re - C.Re;
  Im := Im - C.Im;
end;

procedure Complex.Mult(C: Complex);
var
  tRe: real;
begin
  tRe := Re * C.Re - Im * C.Im;
  Im := Re * C.Im + Im * C.Re;
  Re := tRe;
end;

procedure Complex.Divid(C: Complex);
var
  D, tRe: real;
begin
  D := sqr(C.Re) + sqr(C.Im);
  if D <> 0.0 then begin
    tRe := (Re * C.Re + Im * C.Im) / D;
    Im := (-Re * C.Im + Im * C.Re) / D;
    Re := tRe;
  end
  else begin
    writeln('Division por cero!');
    Re := 1.0;
    Im := 0.0;
  end;
end;

function Complex.Modulo: real;
begin
  Modulo := sqrt(sqr(Re) + sqr(Im));
end;

function Complex.Angulo: real;
begin
  if Re <> 0.0 then
    Angulo := arctan(Im/Re)
  else
    if Im > 0.0 then
      Angulo := Pi/2.0
    else
      if Im = 0.0 then
        Angulo := 0.0
      else
        Angulo := -Pi/2.0;
end;

procedure Complex.Rotar(Ang: real);
begin
  aPolar;
  Im := Im + Ang;
  aRect;
end;

procedure Complex.aRect;
var
  tRe: real;
begin
  tRe := Re * cos(Im);
  Im := Re * sin(Im);
  Re := tRe;
end;

procedure Complex.aPolar;
var
  tRe: real;
begin
  tRe := Modulo;
  Im := Angulo;
  Re := tRe;
end;

begin
end.