I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Arithmetic/Complex

(Redirected from Complex numbers)
Arithmetic/Complex
You are encouraged to solve this task according to the task description, using any language you may know.

A   complex number   is a number which can be written as: ${\displaystyle a+b\times i}$ (sometimes shown as: ${\displaystyle b+a\times i}$ where   ${\displaystyle a}$   and   ${\displaystyle b}$  are real numbers,   and   ${\displaystyle i}$   is    -1

Typically, complex numbers are represented as a pair of real numbers called the "imaginary part" and "real part",   where the imaginary part is the number to be multiplied by ${\displaystyle i}$.

• Show addition, multiplication, negation, and inversion of complex numbers in separate functions. (Subtraction and division operations can be made with pairs of these operations.)
• Print the results for each operation tested.
• Optional: Show complex conjugation.

By definition, the   complex conjugate   of ${\displaystyle a+bi}$ is ${\displaystyle a-bi}$

Some languages have complex number libraries available.   If your language does, show the operations.   If your language does not, also show the definition of this type.

## 11l

Translation of: Python
V z1 = 1.5 + 3iV z2 = 1.5 + 1.5iprint(z1 + z2)print(z1 - z2)print(z1 * z2)print(z1 / z2)print(-z1)print(conjugate(z1))print(abs(z1))print(z1 ^ z2)print(z1.real)print(z1.imag)
Output:
3+4.5i
1.5i
-2.25+6.75i
1.5+0.5i
-1.5-3i
1.5-3i
3.3541
-1.10248-0.383064i
1.5
3


## Action!

INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit DEFINE R_="+0"DEFINE I_="+6"TYPE Complex=[CARD cr1,cr2,cr3,ci1,ci2,ci3] BYTE FUNC Positive(REAL POINTER x)  BYTE ARRAY tmp   tmp=x  IF (tmp(0)&$80)=$00 THEN    RETURN (1)  FIRETURN (0) PROC PrintComplex(Complex POINTER x)  PrintR(x R_)  IF Positive(x I_) THEN    Put('+)  FI  PrintR(x I_) Put('i)RETURN PROC PrintComplexXYZ(Complex POINTER x,y,z CHAR ARRAY s)  Print("(") PrintComplex(x)  Print(") ") Print(s)  Print(" (") PrintComplex(y)  Print(") = ") PrintComplex(z)  PutE()RETURN PROC PrintComplexXY(Complex POINTER x,y CHAR ARRAY s)  Print(s)  Print("(") PrintComplex(x)  Print(") = ") PrintComplex(y)  PutE()RETURN PROC ComplexAdd(Complex POINTER x,y,res)  RealAdd(x R_,y R_,res R_) ;res.r=x.r+y.r  RealAdd(x I_,y I_,res I_) ;res.i=x.i+y.iRETURN PROC ComplexSub(Complex POINTER x,y,res)  RealSub(x R_,y R_,res R_) ;res.r=x.r-y.r  RealSub(x I_,y I_,res I_) ;res.i=x.i-y.iRETURN PROC ComplexMult(Complex POINTER x,y,res)  REAL tmp1,tmp2   RealMult(x R_,y R_,tmp1)  ;tmp1=x.r*y.r  RealMult(x I_,y I_,tmp2)  ;tmp2=x.i*y.i  RealSub(tmp1,tmp2,res R_) ;res.r=x.r*y.r-x.i*y.i   RealMult(x R_,y I_,tmp1)  ;tmp1=x.r*y.i  RealMult(x I_,y R_,tmp2)  ;tmp2=x.i*y.r  RealAdd(tmp1,tmp2,res I_) ;res.i=x.r*y.i+x.i*y.rRETURN PROC ComplexDiv(Complex POINTER x,y,res)  REAL tmp1,tmp2,tmp3,tmp4   RealMult(x R_,y R_,tmp1)  ;tmp1=x.r*y.r  RealMult(x I_,y I_,tmp2)  ;tmp2=x.i*y.i  RealAdd(tmp1,tmp2,tmp3)   ;tmp3=x.r*y.r+x.i*y.i  RealMult(y R_,y R_,tmp1)  ;tmp1=y.r^2  RealMult(y I_,y I_,tmp2)  ;tmp2=y.i^2  RealAdd(tmp1,tmp2,tmp4)   ;tmp4=y.r^2+y.i^2  RealDiv(tmp3,tmp4,res R_) ;res.r=(x.r*y.r+x.i*y.i)/(y.r^2+y.i^2)   RealMult(x I_,y R_,tmp1)  ;tmp1=x.i*y.r  RealMult(x R_,y I_,tmp2)  ;tmp2=x.r*y.i  RealSub(tmp1,tmp2,tmp3)   ;tmp3=x.i*y.r-x.r*y.i  RealDiv(tmp3,tmp4,res I_) ;res.i=(x.i*y.r-x.r*y.i)/(y.r^2+y.i^2)RETURN PROC ComplexNeg(Complex POINTER x,res)  REAL neg   ValR("-1",neg)            ;neg=-1  RealMult(x R_,neg,res R_) ;res.r=-x.r  RealMult(x I_,neg,res I_) ;res.r=-x.rRETURN PROC ComplexInv(Complex POINTER x,res)  REAL tmp1,tmp2,tmp3   RealMult(x R_,x R_,tmp1)  ;tmp1=x.r^2  RealMult(x I_,x I_,tmp2)  ;tmp2=x.i^2  RealAdd(tmp1,tmp2,tmp3)   ;tmp3=x.r^2+x.i^2  RealDiv(x R_,tmp3,res R_) ;res.r=x.r/(x.r^2+x.i^2)   ValR("-1",tmp1)           ;tmp1=-1  RealMult(x I_,tmp1,tmp2)  ;tmp2=-x.i  RealDiv(tmp2,tmp3,res I_) ;res.i=-x.i/(x.r^2+x.i^2)RETURN PROC ComplexConj(Complex POINTER x,res)  REAL neg   ValR("-1",neg)            ;neg=-1  RealAssign(x R_,res R_)   ;res.r=x.r  RealMult(x I_,neg,res I_) ;res.i=-x.iRETURN PROC Main()  Complex x,y,res   IntToReal(5,x R_) IntToReal(3,x I_)  IntToReal(4,y R_) ValR("-3",y I_)   Put(125) PutE() ;clear screen   ComplexAdd(x,y,res)  PrintComplexXYZ(x,y,res,"+")   ComplexSub(x,y,res)  PrintComplexXYZ(x,y,res,"-")   ComplexMult(x,y,res)  PrintComplexXYZ(x,y,res,"*")   ComplexDiv(x,y,res)  PrintComplexXYZ(x,y,res,"/")   ComplexNeg(y,res)  PrintComplexXY(y,res,"        -")   ComplexInv(y,res)  PrintComplexXY(y,res,"     1 / ")   ComplexConj(y,res)  PrintComplexXY(y,res,"     conj")RETURN
Output:
(5+3i) + (4-3i) = 9+0i
(5+3i) - (4-3i) = 1+6i
(5+3i) * (4-3i) = 29-3i
(5+3i) / (4-3i) = .44+1.08i
-(4-3i) = -4+3i
1 / (4-3i) = .16+.12i
conj(4-3i) = 4+3i


with Ada.Numerics.Generic_Complex_Types;with Ada.Text_IO.Complex_IO; procedure Complex_Operations is   -- Ada provides a pre-defined generic package for complex types   -- That package contains definitions for composition,   -- negation, addition, subtraction, multiplication, division,   -- conjugation, exponentiation, and absolute value, as well as   -- basic comparison operations.   -- Ada provides a second pre-defined package for sin, cos, tan, cot,   -- arcsin, arccos, arctan, arccot, and the hyperbolic versions of    -- those trigonometric functions.    -- The package Ada.Numerics.Generic_Complex_Types requires definition   -- with the real type to be used in the complex type definition.    package Complex_Types is new Ada.Numerics.Generic_Complex_Types (Long_Float);   use Complex_Types;   package Complex_IO is new Ada.Text_IO.Complex_IO (Complex_Types);   use Complex_IO;   use Ada.Text_IO;    A : Complex := Compose_From_Cartesian (Re => 1.0, Im => 1.0);   B : Complex := Compose_From_Polar (Modulus => 1.0, Argument => 3.14159);   C : Complex; begin   -- Addition   C := A + B;   Put("A + B = "); Put(C);   New_Line;   -- Multiplication   C := A * B;   Put("A * B = "); Put(C);   New_Line;   -- Inversion   C := 1.0 / A;   Put("1.0 / A = "); Put(C);   New_Line;   -- Negation   C := -A;   Put("-A = "); Put(C);   New_Line;   -- Conjugation   Put("Conjugate(-A) = ");   C := Conjugate (C); Put(C);end Complex_Operations;

## ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
main:(  FORMAT compl fmt = $g(-7,5)"⊥"g(-7,5)$;   PROC compl operations = VOID: (    LONG COMPL a = 1.0 ⊥ 1.0;    LONG COMPL b = 3.14159 ⊥ 1.2;     LONG COMPL c;     printf(($x"a="f(compl fmt)l$,a));    printf(($x"b="f(compl fmt)l$,b));     # addition #    c := a + b;    printf(($x"a+b="f(compl fmt)l$,c));    # multiplication #    c := a * b;    printf(($x"a*b="f(compl fmt)l$,c));    # inversion #    c := 1.0 / a;    printf(($x"1/c="f(compl fmt)l$,c));    # negation #    c := -a;    printf(($x"-a="f(compl fmt)l$,c))  );   compl operations)
Output:

a=1.00000⊥1.00000
b=3.14159⊥1.20000
a+b=4.14159⊥2.20000
a*b=1.94159⊥4.34159
1/c=0.50000⊥-.50000
-a=-1.0000⊥-1.0000



## ALGOL W

Complex is a built-in type in Algol W.

begin    % show some complex arithmetic                                          %    % returns c + d, using the builtin complex + operator                   %    complex procedure cAdd ( complex value c, d ) ; c + d;    % returns c * d, using the builtin complex * operator                   %    complex procedure cMul ( complex value c, d ) ; c * d;    % returns the negation of c, using the builtin complex unary - operator %    complex procedure cNeg ( complex value c ) ; - c;    % returns the inverse of c, using the builtin complex / operatror       %    complex procedure cInv ( complex value c ) ; 1 / c;    % returns the conjugate of c                                            %    complex procedure cConj ( complex value c ) ; realpart( c ) - imag( imagpart( c ) );    complex c, d;    c := 1 + 2i;    d := 3 + 4i;    % set I/O format for real aand complex numbers                          %    r_format := "A"; s_w := 0; r_w := 6; r_d := 2;    write( "c      : ",        c      );    write( "d      : ",           d   );    write( "c + d  : ", cAdd(  c, d ) );    write( "c * d  : ", cMul(  c, d ) );    write( "-c     : ", cNeg(  c    ) );    write( "1/c    : ", cInv(  c    ) );    write( "conj c : ", cConj( c    ) )end.
Output:
c      :   1.00   2.00I
d      :   3.00   4.00I
c + d  :   4.00   6.00I
c * d  :  -5.00  10.00I
-c     :  -1.00  -2.00I
1/c    :   0.20  -0.40I
conj c :   1.00  -2.00I


## APL

    x←1j1                ⍝assignment   y←5.25j1.5   x+y                  ⍝addition6.25J2.5   x×y                  ⍝multiplication3.75J6.75    ⌹x                  ⍝inversion0.5j_0.5    -x                  ⍝negation¯1J¯1

## App Inventor

App Inventor has native support for complex numbers.
The linked image gives a few examples of complex arithmetic and a custom complex conjugate function.
View the blocks and app screen...

## Arturo

a: to :complex [1 1]b: to :complex @[pi 1.2] print ["a:" a]print ["b:" b] print ["a + b:" a + b]print ["a * b:" a * b]print ["1 / a:" 1 / a]print ["neg a:" neg a]print ["conj a:" conj a]
Output:
a: 1.0+1.0i
b: 3.141592653589793+1.2i
a + b: 4.141592653589793+2.2i
a * b: 1.941592653589793+4.341592653589793i
1 / a: 0.5-0.5i
neg a: -1.0-1.0i
conj a: 1.0-1.0i

## AutoHotkey

contributed by Laszlo on the ahk forum

Cset(C,1,1)MsgBox % Cstr(C)  ; 1 + i*1Cneg(C,C)MsgBox % Cstr(C)  ; -1 - i*1Cadd(C,C,C)MsgBox % Cstr(C)  ; -2 - i*2Cinv(D,C)MsgBox % Cstr(D)  ; -0.25 + 0.25*iCmul(C,C,D)MsgBox % Cstr(C)  ; 1 + i*0 Cset(ByRef C, re, im) {   VarSetCapacity(C,16)   NumPut(re,C,0,"double")   NumPut(im,C,8,"double")}Cre(ByRef C) {   Return NumGet(C,0,"double")}Cim(ByRef C) {   Return NumGet(C,8,"double")}Cstr(ByRef C) {   Return Cre(C) ((i:=Cim(C))<0 ? " - i*" . -i : " + i*" . i)}Cadd(ByRef C, ByRef A, ByRef B) {   VarSetCapacity(C,16)   NumPut(Cre(A)+Cre(B),C,0,"double")   NumPut(Cim(A)+Cim(B),C,8,"double")}Cmul(ByRef C, ByRef A, ByRef B) {   VarSetCapacity(C,16)   t := Cre(A)*Cim(B)+Cim(A)*Cre(B)   NumPut(Cre(A)*Cre(B)-Cim(A)*Cim(B),C,0,"double")   NumPut(t,C,8,"double") ; A or B can be C!}Cneg(ByRef C, ByRef A) {   VarSetCapacity(C,16)   NumPut(-Cre(A),C,0,"double")   NumPut(-Cim(A),C,8,"double")}Cinv(ByRef C, ByRef A) {   VarSetCapacity(C,16)   d := Cre(A)**2 + Cim(A)**2   NumPut( Cre(A)/d,C,0,"double")   NumPut(-Cim(A)/d,C,8,"double")}

## AWK

contributed by af

# simulate a struct using associative arraysfunction complex(arr, re, im) {    arr["re"] = re    arr["im"] = im} function re(cmplx) {    return cmplx["re"]} function im(cmplx) {    return cmplx["im"]} function printComplex(cmplx) {    print re(cmplx), im(cmplx)} function abs2(cmplx) {    return re(cmplx) * re(cmplx) + im(cmplx) * im(cmplx)} function abs(cmplx) {    return sqrt(abs2(cmplx))} function add(res, cmplx1, cmplx2) {    complex(res, re(cmplx1) + re(cmplx2), im(cmplx1) + im(cmplx2)) } function mult(res, cmplx1, cmplx2) {    complex(res, re(cmplx1) * re(cmplx2) - im(cmplx1) * im(cmplx2), re(cmplx1) * im(cmplx2) + im(cmplx1) * re(cmplx2))} function scale(res, cmplx, scalar) {    complex(res, re(cmplx) * scalar, im(cmplx) * scalar)} function negate(res, cmplx) {    scale(res, cmplx, -1)} function conjugate(res, cmplx) {    complex(res, re(cmplx), -im(cmplx))} function invert(res, cmplx) {    conjugate(res, cmplx)    scale(res, res, 1 / abs(cmplx))} BEGIN {    complex(i, 0, 1)    mult(i, i, i)    printComplex(i)}

## BASIC

Works with: QuickBasic version 4.5
TYPE complex        real AS DOUBLE        imag AS DOUBLEEND TYPE DECLARE SUB suma (a AS complex, b AS complex, c AS complex)DECLARE SUB rest (a AS complex, b AS complex, c AS complex)DECLARE SUB mult (a AS complex, b AS complex, c AS complex)DECLARE SUB divi (a AS complex, b AS complex, c AS complex)DECLARE SUB neg (a AS complex, b AS complex)DECLARE SUB inv (a AS complex, b AS complex)DECLARE SUB conj (a AS complex, b AS complex) CLSDIM x AS complexDIM y AS complexDIM z AS complexx.real = 1x.imag = 1y.real = 2y.imag = 2 PRINT "Siendo x = "; x.real; "+"; x.imag; "i"PRINT "     e y = "; y.real; "+"; y.imag; "i"PRINTCALL suma(x, y, z)PRINT "x + y = "; z.real; "+"; z.imag; "i"CALL rest(x, y, z)PRINT "x - y = "; z.real; "+"; z.imag; "i"CALL mult(x, y, z)PRINT "x * y = "; z.real; "+"; z.imag; "i"CALL divi(x, y, z)PRINT "x / y = "; z.real; "+"; z.imag; "i"CALL neg(x, z)PRINT "   -x = "; z.real; "+"; z.imag; "i"CALL inv(x, z)PRINT "1 / x = "; z.real; "+"; z.imag; "i"CALL conj(x, z)PRINT "   x* = "; z.real; "+"; z.imag; "i"END SUB suma (a AS complex, b AS complex, c AS complex)        c.real = a.real + b.real        c.imag = a.imag + b.imagEND SUB SUB inv (a AS complex, b AS complex)        denom = a.real ^ 2 + a.imag ^ 2        b.real = a.real / denom        b.imag = -a.imag / denomEND SUB SUB mult (a AS complex, b AS complex, c AS complex)        c.real = a.real * b.real - a.imag * b.imag        c.imag = a.real * b.imag + a.imag * b.realEND SUB SUB neg (a AS complex, b AS complex)        b.real = -a.real        b.imag = -a.imagEND SUB SUB conj (a AS complex, b AS complex)    b.real =  a.real    b.imag = -a.imagEND SUB SUB divi (a AS complex, b AS complex, c AS complex)    c.real = ((a.real * b.real + b.imag * a.imag) / (b.real ^ 2 + b.imag ^ 2))    c.imag = ((a.imag * b.real - a.real * b.imag) / (b.real ^ 2 + b.imag ^ 2))END SUB SUB rest (a AS complex, b AS complex, c AS complex)    c.real = a.real - b.real    c.imag = a.imag - b.imagEND SUB
Output:
Siendo x =  1+ 3i
e y =  5+ 2i

x + y =  6 + 5 i
x - y = -4 + 1 i
x * y = -1 + 17 i
x / y =  .3793103448275862 + .4482758620689655 i
-x = -1 +-3 i
1 / x =  .1 +-.3 i
x* =  1 +-3 i

## BBC BASIC

      DIM Complex{r, i}       DIM a{} = Complex{} : a.r = 1.0 : a.i = 1.0      DIM b{} = Complex{} : b.r = PI# : b.i = 1.2      DIM o{} = Complex{}       PROCcomplexadd(o{}, a{}, b{})      PRINT "Result of addition is " FNcomplexshow(o{})      PROCcomplexmul(o{}, a{}, b{})      PRINT "Result of multiplication is " ; FNcomplexshow(o{})      PROCcomplexneg(o{}, a{})      PRINT "Result of negation is " ; FNcomplexshow(o{})      PROCcomplexinv(o{}, a{})      PRINT "Result of inversion is " ; FNcomplexshow(o{})      END       DEF PROCcomplexadd(dst{}, one{}, two{})      dst.r = one.r + two.r      dst.i = one.i + two.i      ENDPROC       DEF PROCcomplexmul(dst{}, one{}, two{})      dst.r = one.r*two.r - one.i*two.i      dst.i = one.i*two.r + one.r*two.i      ENDPROC       DEF PROCcomplexneg(dst{}, src{})      dst.r = -src.r      dst.i = -src.i      ENDPROC       DEF PROCcomplexinv(dst{}, src{})      LOCAL denom : denom = src.r^2 + src.i^ 2      dst.r = src.r / denom      dst.i = -src.i / denom      ENDPROC       DEF FNcomplexshow(src{})      IF src.i >= 0 THEN = STR$(src.r) + " + " +STR$(src.i) + "i"      = STR$(src.r) + " - " + STR$(-src.i) + "i"
Output:
Result of addition is 4.14159265 + 2.2i
Result of multiplication is 1.94159265 + 4.34159265i
Result of negation is -1 - 1i
Result of inversion is 0.5 - 0.5i

## Bracmat

Bracmat recognizes the symbol i as the square root of -1. The results of the functions below are not necessarily of the form a+b*i, but as the last example shows, Bracmat nevertheless can work out that two different representations of the same mathematical object, when subtracted from each other, give zero. You may wonder why in the functions multiply and negate there are terms 1 and -1. These terms are a trick to force Bracmat to expand the products. As it is more costly to factorize a sum than to expand a product into a sum, Bracmat retains isolated products. However, when in combination with a non-zero term, the product is expanded.

  (add=a b.!arg:(?a,?b)&!a+!b)& ( multiply  = a b.!arg:(?a,?b)&1+!a*!b+-1  )& (negate=.1+-1*!arg+-1)& ( conjugate  =   a b    .   !arg:i&-i      | !arg:-i&i      | !arg:?a_?b&(conjugate$!a)_(conjugate$!b)      | !arg  )& ( invert  =   conjugated    .   conjugate$!arg:?conjugated & multiply$(!arg,!conjugated)^-1*!conjugated  )& out$("(a+i*b)+(a+i*b) =" add$(a+i*b,a+i*b))& out$("(a+i*b)+(a+-i*b) =" add$(a+i*b,a+-i*b))& out$("(a+i*b)*(a+i*b) =" multiply$(a+i*b,a+i*b))& out$("(a+i*b)*(a+-i*b) =" multiply$(a+i*b,a+-i*b))& out$("-1*(a+i*b) =" negate$(a+i*b))& out$("-1*(a+-i*b) =" negate$(a+-i*b))& out$("sin$x = " sin$x)& out$("conjugate sin$x =" conjugate$(sin$x))& out$ ("sin$x minus conjugate sin$x =" sin$x+negate$(conjugate$(sin$x)))& done;
Output:
(a+i*b)+(a+i*b) = 2*a+2*i*b
(a+i*b)+(a+-i*b) = 2*a
(a+i*b)*(a+i*b) = a^2+-1*b^2+2*i*a*b
(a+i*b)*(a+-i*b) = a^2+b^2
-1*(a+i*b) = -1*a+-i*b
-1*(a+-i*b) = -1*a+i*b
sin$x = i*(-1/2*e^(i*x)+1/2*e^(-i*x)) conjugate sin$x  = -i*(1/2*e^(i*x)+-1/2*e^(-i*x))
sin$x minus conjugate sin$x = 0

## C

Works with: C99

The more recent C99 standard has built-in complex number primitive types, which can be declared with float, double, or long double precision. To use these types and their associated library functions, you must include the <complex.h> header. (Note: this is a different header than the <complex> templates that are defined by C++.) [1] [2]

#include <complex.h>#include <stdio.h> void cprint(double complex c){  printf("%f%+fI", creal(c), cimag(c));}void complex_operations() {  double complex a = 1.0 + 1.0I;  double complex b = 3.14159 + 1.2I;   double complex c;   printf("\na="); cprint(a);  printf("\nb="); cprint(b);   // addition  c = a + b;  printf("\na+b="); cprint(c);  // multiplication  c = a * b;  printf("\na*b="); cprint(c);  // inversion  c = 1.0 / a;  printf("\n1/c="); cprint(c);  // negation  c = -a;  printf("\n-a="); cprint(c);  // conjugate  c = conj(a);  printf("\nconj a="); cprint(c); printf("\n");}
Works with: C89

User-defined type:

typedef struct{        double real;        double imag;} Complex; Complex add(Complex a, Complex b){        Complex ans;        ans.real = a.real + b.real;        ans.imag = a.imag + b.imag;        return ans;} Complex mult(Complex a, Complex b){        Complex ans;        ans.real = a.real * b.real - a.imag * b.imag;        ans.imag = a.real * b.imag + a.imag * b.real;        return ans;} /* it's arguable that things could be better handled if either   a.real or a.imag is +/-inf, but that's much work */Complex inv(Complex a){        Complex ans;        double denom = a.real * a.real + a.imag * a.imag;        ans.real =  a.real / denom;        ans.imag = -a.imag / denom;        return ans;} Complex neg(Complex a){        Complex ans;        ans.real = -a.real;        ans.imag = -a.imag;        return ans;} Complex conj(Complex a){        Complex ans;        ans.real =  a.real;        ans.imag = -a.imag;        return ans;} void put(Complex c){         printf("%lf%+lfI", c.real, c.imag);}  void complex_ops(void){   Complex a = { 1.0,     1.0 };  Complex b = { 3.14159, 1.2 };   printf("\na=");   put(a);  printf("\nb=");   put(b);  printf("\na+b="); put(add(a,b));  printf("\na*b="); put(mult(a,b));  printf("\n1/a="); put(inv(a));  printf("\n-a=");  put(neg(a));  printf("\nconj a=");  put(conj(a));  printf("\n");}

## C#

Works with: C sharp version 4.0
namespace RosettaCode.Arithmetic.Complex{    using System;    using System.Numerics;     internal static class Program    {        private static void Main()        {            var number = Complex.ImaginaryOne;            foreach (var result in new[] { number + number, number * number, -number, 1 / number, Complex.Conjugate(number) })            {                Console.WriteLine(result);            }        }    }}
Works with: C sharp version 1.2
using System; public struct ComplexNumber{    public static readonly ComplexNumber i = new ComplexNumber(0.0, 1.0);    public static readonly ComplexNumber Zero = new ComplexNumber(0.0, 0.0);     public double Re;    public double Im;     public ComplexNumber(double re)    {        this.Re = re;        this.Im = 0;    }     public ComplexNumber(double re, double im)    {        this.Re = re;        this.Im = im;    }     public static ComplexNumber operator *(ComplexNumber n1, ComplexNumber n2)    {        return new ComplexNumber(n1.Re * n2.Re - n1.Im * n2.Im,            n1.Im * n2.Re + n1.Re * n2.Im);    }     public static ComplexNumber operator *(double n1, ComplexNumber n2)    {        return new ComplexNumber(n1 * n2.Re, n1 * n2.Im);    }     public static ComplexNumber operator /(ComplexNumber n1, ComplexNumber n2)    {        double n2Norm = n2.Re * n2.Re + n2.Im * n2.Im;        return new ComplexNumber((n1.Re * n2.Re + n1.Im * n2.Im) / n2Norm,            (n1.Im * n2.Re - n1.Re * n2.Im) / n2Norm);    }     public static ComplexNumber operator /(ComplexNumber n1, double n2)    {        return new ComplexNumber(n1.Re / n2, n1.Im / n2);    }     public static ComplexNumber operator +(ComplexNumber n1, ComplexNumber n2)    {        return new ComplexNumber(n1.Re + n2.Re, n1.Im + n2.Im);    }     public static ComplexNumber operator -(ComplexNumber n1, ComplexNumber n2)    {        return new ComplexNumber(n1.Re - n2.Re, n1.Im - n2.Im);    }     public static ComplexNumber operator -(ComplexNumber n)    {        return new ComplexNumber(-n.Re, -n.Im);    }     public static implicit operator ComplexNumber(double n)    {        return new ComplexNumber(n, 0.0);    }     public static explicit operator double(ComplexNumber n)    {        return n.Re;    }     public static bool operator ==(ComplexNumber n1, ComplexNumber n2)    {        return n1.Re == n2.Re && n1.Im == n2.Im;    }     public static bool operator !=(ComplexNumber n1, ComplexNumber n2)    {        return n1.Re != n2.Re || n1.Im != n2.Im;    }     public override bool Equals(object obj)    {        return this == (ComplexNumber)obj;    }     public override int GetHashCode()    {        return Re.GetHashCode() ^ Im.GetHashCode();    }     public override string ToString()    {        return String.Format("{0}+{1}*i", Re, Im);    }} public static class ComplexMath{    public static double Abs(ComplexNumber a)    {        return Math.Sqrt(Norm(a));    }     public static double Norm(ComplexNumber a)    {        return a.Re * a.Re + a.Im * a.Im;    }     public static double Arg(ComplexNumber a)    {        return Math.Atan2(a.Im, a.Re);    }     public static ComplexNumber Inverse(ComplexNumber a)    {        double norm = Norm(a);        return new ComplexNumber(a.Re / norm, -a.Im / norm);    }     public static ComplexNumber Conjugate(ComplexNumber a)    {        return new ComplexNumber(a.Re, -a.Im);     }     public static ComplexNumber Exp(ComplexNumber a)    {        double e = Math.Exp(a.Re);        return new ComplexNumber(e * Math.Cos(a.Im), e * Math.Sin(a.Im));    }     public static ComplexNumber Log(ComplexNumber a)    {         return new ComplexNumber(0.5 * Math.Log(Norm(a)), Arg(a));    }     public static ComplexNumber Power(ComplexNumber a, ComplexNumber power)    {        return Exp(power * Log(a));    }     public static ComplexNumber Power(ComplexNumber a, int power)    {        bool inverse = false;        if (power < 0)        {            inverse = true; power = -power;        }         ComplexNumber result = 1.0;        ComplexNumber multiplier = a;        while (power > 0)        {            if ((power & 1) != 0) result *= multiplier;            multiplier *= multiplier;            power >>= 1;        }         if (inverse)            return Inverse(result);        else            return result;    }     public static ComplexNumber Sqrt(ComplexNumber a)    {        return Exp(0.5 * Log(a));    }     public static ComplexNumber Sin(ComplexNumber a)    {        return Sinh(ComplexNumber.i * a) / ComplexNumber.i;    }     public static ComplexNumber Cos(ComplexNumber a)    {        return Cosh(ComplexNumber.i * a);    }     public static ComplexNumber Sinh(ComplexNumber a)    {        return 0.5 * (Exp(a) - Exp(-a));    }     public static ComplexNumber Cosh(ComplexNumber a)    {        return 0.5 * (Exp(a) + Exp(-a));    } } class Program{    static void Main(string[] args)    {        // usage        ComplexNumber i = 2;        ComplexNumber j = new ComplexNumber(1, -2);        Console.WriteLine(i * j);        Console.WriteLine(ComplexMath.Power(j, 2));        Console.WriteLine((double)ComplexMath.Sin(i) + " vs " + Math.Sin(2));        Console.WriteLine(ComplexMath.Power(j, 0) == 1.0);    }}

## C++

#include <iostream>#include <complex>using std::complex; void complex_operations() {  complex<double> a(1.0, 1.0);  complex<double> b(3.14159, 1.25);   // addition  std::cout << a + b << std::endl;  // multiplication  std::cout << a * b << std::endl;  // inversion  std::cout << 1.0 / a << std::endl;  // negation  std::cout << -a << std::endl;  // conjugate  std::cout << std::conj(a) << std::endl;}

## Clojure

Clojure on the JVM has no native support for Complex numbers. Therefore, we use defrecord and the multimethods in clojure.algo.generic.arithmetic to make a Complex number type.

(ns rosettacode.arithmetic.cmplx  (:require [clojure.algo.generic.arithmetic :as ga])  (:import [java.lang Number])) (defrecord Complex [^Number r ^Number i]  Object  (toString [{:keys [r i]}]    (apply str      (cond        (zero? r) [(if (= i 1) "" i) "i"]        (zero? i) [r]        :else     [r (if (neg? i) "-" "+") i "i"])))) (defmethod ga/+ [Complex Complex]  [x y] (map->Complex (merge-with + x y)))  (defmethod ga/+ [Complex Number] ; reals become y + 0i  [{:keys [r i]} y] (->Complex (+ r y) i)) (defmethod ga/- Complex  [x] (->> x vals (map -) (apply ->Complex))) (defmethod ga/* [Complex Complex]  [x y] (map->Complex (merge-with * x y))) (defmethod ga/* [Complex Number]  [{:keys [r i]} y] (->Complex (* r y) (* i y))) (ga/defmethod* ga / Complex  [x] (->> x vals (map /) (apply ->Complex))) (defn conj [^Complex {:keys [r i]}]  (->Complex r (- i))) (defn inv [^Complex {:keys [r i]}]  (let [m (+ (* r r) (* i i))]    (->Complex (/ r m) (- (/ i m)))))

## COBOL

The following is in the Managed COBOL dialect.

Works with: Visual COBOL

### .NET Complex class

Translation of: C#

## CoffeeScript

 # create an immutable Complex typeclass Complex  constructor: (@r=0, @i=0) ->    @magnitude = @r*@r + @i*@i   plus: (c2) ->    new Complex(      @r + c2.r,      @i + c2.i    )   times: (c2) ->    new Complex(      @r*c2.r - @i*c2.i,      @r*c2.i + @i*c2.r    )   negation: ->    new Complex(      -1 * @r,      -1 * @i    )   inverse: ->    throw Error "no inverse" if @magnitude is 0    new Complex(      @r / @magnitude,      -1 * @i / @magnitude    )   toString: ->    return "#{@r}" if @i == 0    return "#{@i}i" if @r == 0    if @i > 0      "#{@r} + #{@i}i"    else      "#{@r} - #{-1 * @i}i" # testdo ->  a = new Complex(5, 3)  b = new Complex(4, -3)   sum = a.plus b  console.log "(#{a}) + (#{b}) = #{sum}"   product = a.times b  console.log "(#{a}) * (#{b}) = #{product}"   negation = b.negation()  console.log "-1 * (#{b}) = #{negation}"   diff = a.plus negation  console.log "(#{a}) - (#{b}) = #{diff}"   inverse = b.inverse()  console.log "1 / (#{b}) = #{inverse}"   quotient = product.times inverse  console.log "(#{product}) / (#{b}) = #{quotient}"
Output:
> coffee complex.coffee
(5 + 3i) + (4 - 3i) = 9
(5 + 3i) * (4 - 3i) = 29 - 3i
-1 * (4 - 3i) = -4 + 3i
(5 + 3i) - (4 - 3i) = 1 + 6i
1 / (4 - 3i) = 0.16 + 0.12i
(29 - 3i) / (4 - 3i) = 5 + 3i


## Common Lisp

Complex numbers are a built-in numeric type in Common Lisp. The literal syntax for a complex number is #C(real imaginary). The components of a complex number may be integers, ratios, or floating-point. Arithmetic operations automatically return complex (or real) numbers when appropriate:

> (sqrt -1)#C(0.0 1.0) > (expt #c(0 1) 2)-1

Here are some arithmetic operations on complex numbers:

> (+ #c(0 1) #c(1 0))#C(1 1) > (* #c(1 1) 2)#C(2 2) > (* #c(1 1) #c(0 2))#C(-2 2) > (- #c(1 1))#C(-1 -1) > (/ #c(0 2))#C(0 -1/2) > (conjugate #c(1 1))#C(1 -1)

Complex numbers can be constructed from real and imaginary parts using the complex function, and taken apart using the realpart and imagpart functions.

> (complex 64 (/ 3 4))#C(64 3/4) > (realpart #c(5 5))5 > (imagpart (complex 0 pi))3.141592653589793d0

## Component Pascal

BlackBox Component Builder

 MODULE Complex;IMPORT StdLog;TYPE        Complex* = POINTER TO ComplexDesc;        ComplexDesc = RECORD                r-,i-: REAL;        END; VAR        r,x,y: Complex; PROCEDURE New(x,y: REAL): Complex;VAR        r: Complex;BEGIN        NEW(r);r.r := x;r.i := y;        RETURN rEND New; PROCEDURE (x: Complex) Add*(y: Complex): Complex,NEW;BEGIN        RETURN New(x.r + y.r,x.i + y.i)END Add; PROCEDURE ( x: Complex) Sub*( y: Complex): Complex, NEW;BEGIN        RETURN New(x.r - y.r,x.i - y.i)END Sub; PROCEDURE ( x: Complex) Mul*( y: Complex): Complex, NEW;BEGIN        RETURN New(x.r*y.r - x.i*y.i,x.r*y.i + x.i*y.r)END Mul; PROCEDURE ( x: Complex) Div*( y: Complex): Complex, NEW;VAR        d: REAL;BEGIN        d := y.r * y.r + y.i * y.i;        RETURN New((x.r*y.r + x.i*y.i)/d,(x.i*y.r - x.r*y.i)/d)END Div; (* Reciprocal *)PROCEDURE (x: Complex) Rec*(): Complex,NEW;VAR        d: REAL;BEGIN        d := x.r * x.r + x.i * x.i;        RETURN New(x.r/d,(-1.0 * x.i)/d);END Rec; (* Conjugate *)PROCEDURE (x: Complex) Con*(): Complex,NEW;BEGIN        RETURN New(x.r, (-1.0) * x.i);END Con; PROCEDURE (x: Complex) Out(),NEW;BEGIN	   StdLog.String("Complex(");	   StdLog.Real(x.r);StdLog.String(',');StdLog.Real(x.i);	   StdLog.String("i );")END Out; PROCEDURE Do*;BEGIN        x := New(1.5,3);        y := New(1.0,1.0);         StdLog.String("x: ");x.Out();StdLog.Ln;        StdLog.String("y: ");y.Out();StdLog.Ln;                r := x.Add(y);        StdLog.String("x + y: ");r.Out();StdLog.Ln;        r := x.Sub(y);        StdLog.String("x - y: ");r.Out();StdLog.Ln;        r := x.Mul(y);        StdLog.String("x * y: ");r.Out();StdLog.Ln;        r := x.Div(y);        StdLog.String("x / y: ");r.Out();StdLog.Ln;        r := y.Rec();        StdLog.String("1 / y: ");r.Out();StdLog.Ln;        r := x.Con();        StdLog.String("x': ");r.Out();StdLog.Ln;END Do; END Complex.

Execute: ^Q Complex.Do

Output:
x: Complex( 1.5, 3.0i );
y: Complex( 1.0, 1.0i );
x + y: Complex( 2.5, 4.0i );
x - y: Complex( 0.5, 2.0i );
x * y: Complex( -1.5, 4.5i );
x / y: Complex( 2.25, 0.75i );
1 / y: Complex( 0.5, -0.5i );
x': Complex( 1.5, -3.0i );


## D

Built-in complex numbers are now deprecated in D, to simplify the language.

import std.stdio, std.complex; void main() {    auto x = complex(1, 1); // complex of doubles on default    auto y = complex(3.14159, 1.2);     writeln(x + y);   // addition      writeln(x * y);   // multiplication    writeln(1.0 / x); // inversion    writeln(-x);      // negation}
Output:
4.14159+2.2i
1.94159+4.34159i
0.5-0.5i
-1-1i

## Dart

  class complex {   num real=0;  num imag=0;   complex(num r,num i){    this.real=r;    this.imag=i;  }     complex add(complex b){    return new complex(this.real + b.real, this.imag + b.imag);  }   complex mult(complex b){    //FOIL of (a+bi)(c+di) with i*i = -1    return new complex(this.real * b.real - this.imag * b.imag, this.real * b.imag + this.imag * b.real);  }   complex inv(){    //1/(a+bi) * (a-bi)/(a-bi) = 1/(a+bi) but it's more workable    num denom = real * real + imag * imag;    double r =real/denom;    double i= -imag/denom;    return new complex( r,-i);  }   complex neg(){    return new complex(-real, -imag);  }   complex conj(){    return new complex(real, -imag);  }  String toString(){  return    this.real.toString()+' + '+ this.imag.toString()+'*i';}}void main() {  var cl= new complex(1,2);  var cl2= new complex(3,-1);  print(cl.toString());  print(cl2.toString());  print(cl.inv().toString());  print(cl2.mult(cl).toString()); }

 program Arithmetic_Complex; {$APPTYPE CONSOLE} uses System.SysUtils, System.VarCmplx; var a, b: Variant; begin a := VarComplexCreate(5, 3); b := VarComplexCreate(0.5, 6.0); writeln(format('(%s) + (%s) = %s',[a,b, a+b])); writeln(format('(%s) * (%s) = %s',[a,b, a*b])); writeln(format('-(%s) = %s',[a,- a])); writeln(format('1/(%s) = %s',[a,1/a])); writeln(format('conj(%s) = %s',[a,VarComplexConjugate(a)])); Readln;end. Output: (5 + 3i) + (0,5 + 6i) = 5,5 + 9i (5 + 3i) * (0,5 + 6i) = -15,5 + 31,5i -(5 + 3i) = -5 - 3i 1/(5 + 3i) = 0,147058823529412 - 0,0882352941176471i conj(5 + 3i) = 5 - 3i ## EchoLisp Complex numbers are part of the language. No special library is needed.  (define a 42+666i) → a(define b 1+i) → b(- a) → -42-666i ; negate(+ a b) → 43+667i ; add(* a b) → -624+708i ; multiply(/ b) → 0.5-0.5i ; invert(conjugate b) → 1-i(angle b) → 0.7853981633974483 ; = PI/4(magnitude b) → 1.4142135623730951 ; = sqrt(2)(exp (* I PI)) → -1+0i ; Euler = e^(I*PI) = -1  ## Elixir defmodule Complex do import Kernel, except: [abs: 1, div: 2] defstruct real: 0, imag: 0 def new(real, imag) do %__MODULE__{real: real, imag: imag} end def add(a, b) do {a, b} = convert(a, b) new(a.real + b.real, a.imag + b.imag) end def sub(a, b) do {a, b} = convert(a, b) new(a.real - b.real, a.imag - b.imag) end def mul(a, b) do {a, b} = convert(a, b) new(a.real*b.real - a.imag*b.imag, a.imag*b.real + a.real*b.imag) end def div(a, b) do {a, b} = convert(a, b) divisor = abs2(b) new((a.real*b.real + a.imag*b.imag) / divisor, (a.imag*b.real - a.real*b.imag) / divisor) end def neg(a) do a = convert(a) new(-a.real, -a.imag) end def inv(a) do a = convert(a) divisor = abs2(a) new(a.real / divisor, -a.imag / divisor) end def conj(a) do a = convert(a) new(a.real, -a.imag) end def abs(a) do :math.sqrt(abs2(a)) end defp abs2(a) do a = convert(a) a.real*a.real + a.imag*a.imag end defp convert(a) when is_number(a), do: new(a, 0) defp convert(%__MODULE__{} = a), do: a defp convert(a, b), do: {convert(a), convert(b)} def task do a = new(1, 3) b = new(5, 2) IO.puts "a = #{a}" IO.puts "b = #{b}" IO.puts "add(a,b): #{add(a, b)}" IO.puts "sub(a,b): #{sub(a, b)}" IO.puts "mul(a,b): #{mul(a, b)}" IO.puts "div(a,b): #{div(a, b)}" IO.puts "div(b,a): #{div(b, a)}" IO.puts "neg(a) : #{neg(a)}" IO.puts "inv(a) : #{inv(a)}" IO.puts "conj(a) : #{conj(a)}" endend defimpl String.Chars, for: Complex do def to_string(%Complex{real: real, imag: imag}) do if imag >= 0, do: "#{real}+#{imag}j", else: "#{real}#{imag}j" endend Complex.task Output: a = 1+3j b = 5+2j add(a,b): 6+5j sub(a,b): -4+1j mul(a,b): -1+17j div(a,b): 0.3793103448275862+0.4482758620689655j div(b,a): 1.1-1.3j neg(a) : -1-3j inv(a) : 0.1-0.3j conj(a) : 1-3j  ## Erlang %% Task: Complex Arithmetic%% Author: Abhay Jain -module(complex_number).-export([calculate/0]). -record(complex, {real, img}). calculate() -> A = #complex{real=1, img=3}, B = #complex{real=5, img=2}, Sum = add (A, B), print (Sum), Product = multiply (A, B), print (Product), Negation = negation (A), print (Negation), Inversion = inverse (A), print (Inversion), Conjugate = conjugate (A), print (Conjugate). add (A, B) -> RealPart = A#complex.real + B#complex.real, ImgPart = A#complex.img + B#complex.img, #complex{real=RealPart, img=ImgPart}. multiply (A, B) -> RealPart = (A#complex.real * B#complex.real) - (A#complex.img * B#complex.img), ImgPart = (A#complex.real * B#complex.img) + (B#complex.real * A#complex.img), #complex{real=RealPart, img=ImgPart}. negation (A) -> #complex{real=-A#complex.real, img=-A#complex.img}. inverse (A) -> C = conjugate (A), Mod = (A#complex.real * A#complex.real) + (A#complex.img * A#complex.img), RealPart = C#complex.real / Mod, ImgPart = C#complex.img / Mod, #complex{real=RealPart, img=ImgPart}. conjugate (A) -> RealPart = A#complex.real, ImgPart = -A#complex.img, #complex{real=RealPart, img=ImgPart}. print (A) -> if A#complex.img < 0 -> io:format("Ans = ~p~pi~n", [A#complex.real, A#complex.img]); true -> io:format("Ans = ~p+~pi~n", [A#complex.real, A#complex.img]) end.  Output: Ans = 6+5iAns = -1+17iAns = -1-3iAns = 0.1-0.3iAns = 1-3i ## ERRE  PROGRAM COMPLEX_ARITH TYPE COMPLEX=(REAL#,IMAG#) DIM X:COMPLEX,Y:COMPLEX,Z:COMPLEX !! complex arithmetic routines!DIM A:COMPLEX,B:COMPLEX,C:COMPLEX PROCEDURE ADD(A.,B.->C.) C.REAL#=A.REAL#+B.REAL# C.IMAG#=A.IMAG#+B.IMAG#END PROCEDURE PROCEDURE INV(A.->B.) LOCAL DENOM# DENOM#=A.REAL#^2+A.IMAG#^2 B.REAL#=A.REAL#/DENOM# B.IMAG#=-A.IMAG#/DENOM#END PROCEDURE PROCEDURE MULT(A.,B.->C.) C.REAL#=A.REAL#*B.REAL#-A.IMAG#*B.IMAG# C.IMAG#=A.REAL#*B.IMAG#+A.IMAG#*B.REAL#END PROCEDURE PROCEDURE NEG(A.->B.) B.REAL#=-A.REAL# B.IMAG#=-A.IMAG#END PROCEDURE BEGIN PRINT(CHR$(12);) !CLS    X.REAL#=1    X.IMAG#=1    Y.REAL#=2    Y.IMAG#=2    ADD(X.,Y.->Z.)    PRINT(Z.REAL#;" + ";Z.IMAG#;"i")    MULT(X.,Y.->Z.)    PRINT(Z.REAL#;" + ";Z.IMAG#;"i")    INV(X.->Z.)    PRINT(Z.REAL#;" + ";Z.IMAG#;"i")    NEG(X.->Z.)    PRINT(Z.REAL#;" + ";Z.IMAG#;"i")END PROGRAM

Note: Adapted from QuickBasic source code

Output:
 3 + 3 i
0 + 4 i
.5 +-.5 i
-1 +-1 i

## Euler Math Toolbox

 >a=1+4i; b=5-3i;>a+b 6+1i>a-b -4+7i>a*b 17+17i>a/b -0.205882352941+0.676470588235i>fraction a/b -7/34+23/34i>conj(a) 1-4i

## Euphoria

constant REAL = 1, IMAG = 2type complex(sequence s)    return length(s) = 2 and atom(s[REAL]) and atom(s[IMAG])end type function add(complex a, complex b)    return a + bend function function mult(complex a, complex b)    return {a[REAL] * b[REAL] - a[IMAG] * b[IMAG],        a[REAL] * b[IMAG] + a[IMAG] * b[REAL]}end function function inv(complex a)    atom denom    denom = a[REAL] * a[REAL] + a[IMAG] * a[IMAG]    return {a[REAL] / denom, -a[IMAG] / denom}end function function neg(complex a)    return -aend function function scomplex(complex a)    sequence s    if a[REAL] != 0 then        s = sprintf("%g",a)    else        s = {}    end if     if a[IMAG] != 0 then        if a[IMAG] = 1 then            s &= "+i"        elsif a[IMAG] = -1 then            s &= "-i"        else            s &= sprintf("%+gi",a[IMAG])        end if    end if     if length(s) = 0 then        return "0"    else        return s    end ifend function complex a, ba = { 1.0,     1.0 }b = { 3.14159, 1.2 }printf(1,"a = %s\n",{scomplex(a)})printf(1,"b = %s\n",{scomplex(b)})printf(1,"a+b = %s\n",{scomplex(add(a,b))})printf(1,"a*b = %s\n",{scomplex(mult(a,b))})printf(1,"1/a = %s\n",{scomplex(inv(a))})printf(1,"-a = %s\n",{scomplex(neg(a))})
Output:
a = 1+i
b = 3.14159+1.2i
a+b = 4.14159+2.2i
a*b = 1.94159+4.34159i
1/a = 0.5-0.5i
-a = -1-i

## Excel

Take 7 cells, say A1 to G1. Type in :

C1:

 =IMSUM(A1;B1)

D1:

 =IMPRODUCT(A1;B1)

E1:

 =IMSUB(0;D1)

F1:

 =IMDIV(1;E28)

G1:

 =IMCONJUGATE(C28)

E1 will have the negation of D1's value

 1+2i	3+5i	4+7i	-7+11i	7-11i	0,0411764705882353+0,0647058823529412i	4-7i

## F#

Entered into an interactive session to show the results:

 > open Microsoft.FSharp.Math;; > let a = complex 1.0 1.0;;val a : complex = 1r+1i > let b = complex 3.14159 1.25;;val b : complex = 3.14159r+1.25i > a + b;;val it : Complex = 4.14159r+2.25i {Conjugate = 4.14159r-2.25i;                                   ImaginaryPart = 2.25;                                   Magnitude = 4.713307515;                                   Phase = 0.497661247;                                   RealPart = 4.14159;                                   i = 2.25;                                   r = 4.14159;} > a * b;;val it : Complex = 1.89159r+4.39159i {Conjugate = 1.89159r-4.39159i;                                      ImaginaryPart = 4.39159;                                      Magnitude = 4.781649868;                                      Phase = 1.164082262;                                      RealPart = 1.89159;                                      i = 4.39159;                                      r = 1.89159;} > a / b;;val it : Complex =  0.384145932435901r+0.165463215905043i    {Conjugate = 0.384145932435901r-0.165463215905043i;     ImaginaryPart = 0.1654632159;     Magnitude = 0.418265673;     Phase = 0.4067140652;     RealPart = 0.3841459324;     i = 0.1654632159;     r = 0.3841459324;} > -a;;val it : complex = -1r-1i {Conjugate = -1r+1i;                           ImaginaryPart = -1.0;                           Magnitude = 1.414213562;                           Phase = -2.35619449;                           RealPart = -1.0;                           i = -1.0;                           r = -1.0;}

## Factor

USING: combinators kernel math math.functions prettyprint ; C{ 1 2 } C{ 0.9 -2.78 } {    [ + . ]             ! addition    [ - . ]             ! subtraction    [ * . ]             ! multiplication    [ / . ]             ! division    [ ^ . ]             ! power} 2cleave C{ 1 2 } {    [ neg . ]           ! negation    [ recip . ]         ! multiplicative inverse    [ conjugate . ]     ! complex conjugate    [ sin . ]           ! sine    [ log . ]           ! natural logarithm    [ sqrt . ]          ! square root} cleave

## Forth

Historically, there was no standard syntax or mechanism for complex numbers and several implementations suitable for different uses were provided. However later a wordset was standardised as "Algorithm #60".

S" fsl-util.fs" REQUIREDS" complex.fs" REQUIRED zvariable xzvariable y1e 1e   x z!pi 1.2e y z! x [email protected] y [email protected] z+ z.x [email protected] y [email protected] z* z.1e 0e zconstant 1+0i1+0i x [email protected] z/ z.x [email protected] znegate z.

## Fortran

In ANSI FORTRAN 66 or later, COMPLEX is a built-in data type with full access to intrinsic arithmetic operations. Putting each native operation in a function is horribly inefficient, so I will simply demonstrate the operations. This example shows usage for Fortran 90 or later:

program cdemo    complex :: a = (5,3), b = (0.5, 6.0)      ! complex initializer    complex :: absum, abprod, aneg, ainv     absum  = a + b    abprod = a * b    aneg   = -a    ainv   = 1.0 / aend program cdemo

And, although you did not ask, here are demonstrations of some other common complex number operations

program cdemo2    complex :: a = (5,3), b = (0.5, 6)        ! complex initializer    real, parameter :: pi = 3.141592653589793 ! The constant "pi"    complex, parameter :: i = (0, 1)          ! the imaginary unit "i" (sqrt(-1))    complex :: abdiff, abquot, abpow, aconj, p2cart, newc    real :: areal, aimag, anorm, rho = 10, theta = pi / 3.0, x = 2.3, y = 3.0    integer, parameter :: n = 50    integer :: j    complex, dimension(0:n-1) :: unit_circle     abdiff = a - b    abquot = a / b    abpow  = a ** b    areal = real(a)               ! Real part    aimag = imag(a)               ! Imaginary part. Function imag(a) is possibly not recognised. Use aimag(a) if so.    newc = cmplx(x,y)             ! Creating a complex on the fly from two reals intrinsically                                  !   (initializer only works in declarations)    newc = x + y*i                ! Creating a complex on the fly from two reals arithmetically    anorm = abs(a)                ! Complex norm (or "modulus" or "absolute value")                                  !   (use CABS before Fortran 90)    aconj = conjg(a)              ! Complex conjugate (same as real(a) - i*imag(a))    p2cart = rho * exp(i * theta) ! Euler's polar complex notation to cartesian complex notation                                  !   conversion (use CEXP before Fortran 90)     ! The following creates an array of N evenly spaced points around the complex unit circle    ! useful for FFT calculations, among other things    unit_circle = exp(2*i*pi/n * (/ (j, j=0, n-1) /) ) end program cdemo2

## FreeBASIC

' FB 1.05.0 Win64 Type Complex  As Double real, imag   Declare Constructor(real As Double, imag As Double)  Declare Function invert() As Complex  Declare Function conjugate() As Complex  Declare Operator cast() As String  End Type Constructor Complex(real As Double, imag As Double)  This.real = real  This.imag = imagEnd Constructor Function Complex.invert() As Complex  Dim denom As Double = real * real + imag * imag  Return Complex(real / denom, -imag / denom)End Function  Function Complex.conjugate() As Complex  Return Complex(real, -imag)End Function Operator Complex.Cast() As String  If imag >= 0 Then     Return Str(real) + "+" + Str(imag) + "j"  End If  Return Str(real) + Str(imag) + "j" End Operator Operator - (c As Complex) As Complex   Return Complex(-c.real, -c.imag)End Operator Operator + (c1 As Complex, c2 As Complex) As Complex  Return Complex(c1.real + c2.real, c1.imag + c2.imag)End Operator Operator - (c1 As Complex, c2 As Complex) As Complex  Return c1 + (-c2)End Operator Operator * (c1 As Complex, c2 As Complex) As Complex  Return Complex(c1.real * c2.real - c1.imag * c2.imag, c1.real * c2.imag + c2.real * c1.imag)End Operator Operator / (c1 As Complex, c2 As Complex) As Complex  Return c1 * c2.invert End Operator Var x = Complex(1, 3)Var y = Complex(5, 2)Print "x     = "; xPrint "y     = "; yPrint "x + y = "; x + yPrint "x - y = "; x - yPrint "x * y = "; x * yPrint "x / y = "; x / yPrint "-x    = "; -xPrint "1 / x = "; x.invertPrint "x*    = "; x.conjugatePrintPrint "Press any key to quit"Sleep
Output:
x     = 1+3j
y     = 5+2j
x + y = 6+5j
x - y = -4+1j
x * y = -1+17j
x / y = 0.3793103448275862+0.4482758620689655j
-x    = -1-3j
1 / x = 0.1-0.3j
x*    = 1-3j


## Free Pascal

FreePascal has a complex units. Example of usage:

Program ComplexDemo; uses  ucomplex; var  a, b, absum, abprod, aneg, ainv, acong: complex; function complex(const re, im: real): ucomplex.complex; overload;  begin    complex.re := re;    complex.im := im;  end; begin  a      := complex(5, 3);  b      := complex(0.5, 6.0);  absum  := a + b;  writeln ('(5 + i3) + (0.5 + i6.0): ', absum.re:3:1, ' + i', absum.im:3:1);  abprod := a * b;  writeln ('(5 + i3) * (0.5 + i6.0): ', abprod.re:5:1, ' + i', abprod.im:4:1);  aneg   := -a;  writeln ('-(5 + i3): ', aneg.re:3:1, ' + i', aneg.im:3:1);  ainv   := 1.0 / a;  writeln ('1/(5 + i3): ', ainv.re:3:1, ' + i', ainv.im:3:1);  acong  := cong(a);  writeln ('conj(5 + i3): ', acong.re:3:1, ' + i', acong.im:3:1);end.

## Frink

Frink's operations handle complex numbers naturally. The real and imaginary parts of complex numbers can be arbitrary-sized integers, arbitrary-sized rational numbers, or arbitrary-precision floating-point numbers.

 add[x,y] := x + ymultiply[x,y] := x * ynegate[x] := -xinvert[x] := 1/x  // Could also use inv[x] or recip[x]conjugate[x] := Re[x] - Im[x] i a = 3 + 2.5ib = 7.3 - 10iprintln["$a +$b = " + add[a,b]]println["$a *$b = " + multiply[a,b]]println["-$a = " + negate[a]]println["1/$a = " + invert[a]]println["conjugate[$a] = " + conjugate[a]]  Output: ( 3 + 2.5 i ) + ( 7.3 - 10 i ) = ( 10.3 - 7.5 i ) ( 3 + 2.5 i ) * ( 7.3 - 10 i ) = ( 46.9 - 11.75 i ) -( 3 + 2.5 i ) = ( -3 - 2.5 i ) 1/( 3 + 2.5 i ) = ( 0.19672131147540983607 - 0.16393442622950819672 i ) conjugate[( 3 + 2.5 i )] = ( 3 - 2.5 i )  ## Futhark  This example is incorrect. Please fix the code and remove this message.Details: Futhark's syntax has changed, so "fun" should be "let"  type complex = (f64,f64) fun complexAdd((a,b): complex) ((c,d): complex): complex = (a + c, b + d) fun complexMult((a,b): complex) ((c,d): complex): complex = (a*c - b * d, a*d + b * c) fun complexInv((r,i): complex): complex = let denom = r*r + i * i in (r / denom, -i / denom) fun complexNeg((r,i): complex): complex = (-r, -i) fun complexConj((r,i): complex): complex = (r, -i) fun main (o: int) (a: complex) (b: complex): complex = if o == 0 then complexAdd a b else if o == 1 then complexMult a b else if o == 2 then complexInv a else if o == 3 then complexNeg a else complexConj a  ## GAP # GAP knows gaussian integers, gaussian rationals (i.e. Q[i]), and cyclotomic fields. Here are some examples.# E(n) is an nth primitive root of 1i := Sqrt(-1);# E(4)(3 + 2*i)*(5 - 7*i);# 29-11*E(4)1/i;# -E(4)Sqrt(-3);# E(3)-E(3)^2 i in GaussianIntegers;# truei/2 in GaussianIntegers;# falsei/2 in GaussianRationals;# trueSqrt(-3) in Cyclotomics;# true ## Go Go has complex numbers built in, with the complex conjugate in the standard library. package main import ( "fmt" "math/cmplx") func main() { a := 1 + 1i b := 3.14159 + 1.25i fmt.Println("a: ", a) fmt.Println("b: ", b) fmt.Println("a + b: ", a+b) fmt.Println("a * b: ", a*b) fmt.Println("-a: ", -a) fmt.Println("1 / a: ", 1/a) fmt.Println("a̅: ", cmplx.Conj(a))} Output: a: (1+1i) b: (3.14159+1.25i) a + b: (4.14159+2.25i) a * b: (1.8915899999999999+4.39159i) -a: (-1-1i) 1 / a: (0.5-0.5i) a̅: (1-1i)  ## Groovy Groovy does not provide any built-in facility for complex arithmetic. However, it does support arithmetic operator overloading. Thus it is not too hard to build a fairly robust, complete, and intuitive complex number class, such as the following: class Complex { final Number real, imag static final Complex i = [0,1] as Complex Complex(Number r, Number i = 0) { (real, imag) = [r, i] } Complex(Map that) { (real, imag) = [that.real ?: 0, that.imag ?: 0] } Complex plus (Complex c) { [real + c.real, imag + c.imag] as Complex } Complex plus (Number n) { [real + n, imag] as Complex } Complex minus (Complex c) { [real - c.real, imag - c.imag] as Complex } Complex minus (Number n) { [real - n, imag] as Complex } Complex multiply (Complex c) { [real*c.real - imag*c.imag , imag*c.real + real*c.imag] as Complex } Complex multiply (Number n) { [real*n , imag*n] as Complex } Complex div (Complex c) { this * c.recip() } Complex div (Number n) { this * (1/n) } Complex negative () { [-real, -imag] as Complex } /** the complex conjugate of this complex number. Overloads the bitwise complement (~) operator. */ Complex bitwiseNegate () { [real, -imag] as Complex } /** the magnitude of this complex number. */ // could also use Math.sqrt( (this * (~this)).real ) Number getAbs() { Math.sqrt( real*real + imag*imag ) } /** the magnitude of this complex number. */ Number abs() { this.abs } /** the reciprocal of this complex number. */ Complex getRecip() { (~this) / (ρ**2) } /** the reciprocal of this complex number. */ Complex recip() { this.recip } /** derived polar angle θ (theta) for polar form. Normalized to 0 ≤ θ < 2π. */ Number getTheta() { def θ = Math.atan2(imag,real) θ = θ < 0 ? θ + 2 * Math.PI : θ } /** derived polar angle θ (theta) for polar form. Normalized to 0 ≤ θ < 2π. */ Number getΘ() { this.theta } // this is greek uppercase theta /** derived polar magnitude ρ (rho) for polar form. */ Number getRho() { this.abs } /** derived polar magnitude ρ (rho) for polar form. */ Number getΡ() { this.abs } // this is greek uppercase rho, not roman P /** Runs Euler's polar-to-Cartesian complex conversion, * converting [ρ, θ] inputs into a [real, imag]-based complex number */ static Complex fromPolar(Number ρ, Number θ) { [ρ * Math.cos(θ), ρ * Math.sin(θ)] as Complex } /** Creates new complex with same magnitude ρ, but different angle θ */ Complex withTheta(Number θ) { fromPolar(this.rho, θ) } /** Creates new complex with same magnitude ρ, but different angle θ */ Complex withΘ(Number θ) { fromPolar(this.rho, θ) } /** Creates new complex with same angle θ, but different magnitude ρ */ Complex withRho(Number ρ) { fromPolar(ρ, this.θ) } /** Creates new complex with same angle θ, but different magnitude ρ */ Complex withΡ(Number ρ) { fromPolar(ρ, this.θ) } // this is greek uppercase rho, not roman P static Complex exp(Complex c) { fromPolar(Math.exp(c.real), c.imag) } static Complex log(Complex c) { [Math.log(c.rho), c.theta] as Complex } Complex power(Complex c) { this == 0 && c != 0 \ ? [0] as Complex \ : c == 1 \ ? this \ : exp( log(this) * c ) } Complex power(Number n) { this ** ([n, 0] as Complex) } boolean equals(that) { that != null && (that instanceof Complex \ ? [this.real, this.imag] == [that.real, that.imag] \ : that instanceof Number && [this.real, this.imag] == [that, 0]) } int hashCode() { [real, imag].hashCode() } String toString() { def realPart = "${real}"        def imagPart = imag.abs() == 1 ? "i" : "${imag.abs()}i" real == 0 && imag == 0 \ ? "0" \ : real == 0 \ ? (imag > 0 ? '' : "-") + imagPart \ : imag == 0 \ ? realPart \ : realPart + (imag > 0 ? " + " : " - ") + imagPart }} The following ComplexCategory class allows for modification of regular Number behavior when interacting with Complex. import org.codehaus.groovy.runtime.DefaultGroovyMethods class ComplexCategory { static Complex getI (Number a) { [0, a] as Complex } static Complex plus (Number a, Complex b) { b + a } static Complex minus (Number a, Complex b) { -b + a } static Complex multiply (Number a, Complex b) { b * a } static Complex div (Number a, Complex b) { ([a] as Complex) / b } static Complex power (Number a, Complex b) { ([a] as Complex) ** b } static <T> T asType (Number a, Class<T> type) { type == Complex \ ? [a] as Complex : DefaultGroovyMethods.asType(a, type) }} Notice also that this solution takes liberal advantage of Groovy's full Unicode support, including support for non-English alphabets used in identifiers. Test Program (mixes the ComplexCategory methods into the Number class): import static Complex.* Number.metaClass.mixin ComplexCategory def ε = 0.000000001 // tolerance (epsilon): acceptable "wrongness" to account for rounding error println 'Demo 1: functionality as requested'def a = [5,3] as Complexdef a1 = [real:5, imag:3] as Complexdef a2 = 5 + 3.idef a3 = 5 + 3*iassert a == a1 && a == a2 && a == a3println 'a == ' + adef b = [0.5,6] as Complexprintln 'b == ' + b println "a + b == (${a}) + (${b}) == " + (a + b)println "a * b == (${a}) * (${b}) == " + (a * b)assert a + (-a) == 0println "-a == -(${a}) == " + (-a)assert (a * a.recip - 1).abs < εprintln "1/a == (${a}).recip == " + (a.recip)println "a * 1/a == " + (a * a.recip)println() println 'Demo 2: other functionality not requested, but important for completeness'def c = 10def d = 10 as Complexassert d instanceof Complex && c instanceof Number && d == cassert a + c == c + aprintln "a + 10 == 10 + a == " + (c + a)assert c - a == -(a - c)println "10 - a == -(a - 10) == " + (c - a)println "a - b == (${a}) - (${b}) == " + (a - b)assert c * a == a * cprintln "10 * a == a * 10 == " + (c * a)assert (c / a - (a / c).recip).abs < εprintln "10 / a == 1 / (a / 10) == " + (c / a)println "a / b == (${a}) / (${b}) == " + (a / b)assert (a ** 2 - a * a).abs < εprintln "a ** 2 == a * a == " + (a ** 2)println "0.9 ** b == " + (0.9 ** b)println "a ** b == (${a}) ** (${b}) == " + (a ** b)println 'a.real == ' + a.realprintln 'a.imag == ' + a.imagprintln '|a| == ' + a.absprintln 'a.rho == ' + a.rhoprintln 'a.ρ == ' + a.ρprintln 'a.theta == ' + a.thetaprintln 'a.θ == ' + a.θprintln '~a (conjugate) == ' + ~a def ρ = 10def π = Math.PIdef n = 3def θ = π / n def fromPolar1 = fromPolar(ρ, θ) // direct polar-to-cartesian conversiondef fromPolar2 = exp(θ.i) * ρ // Euler's equationprintln "ρ*cos(θ) + i*ρ*sin(θ) ==${ρ}*cos(π/${n}) + i*${ρ}*sin(π/${n})"println " == 10*0.5 + i*10*√(3/4) == " + fromPolar1println "ρ*exp(i*θ) ==${ρ}*exp(i*π/${n}) == " + fromPolar2assert (fromPolar1 - fromPolar2).abs < ε Output: Demo 1: functionality as requested a == 5 + 3i b == 0.5 + 6i a + b == (5 + 3i) + (0.5 + 6i) == 5.5 + 9i a * b == (5 + 3i) * (0.5 + 6i) == -15.5 + 31.5i -a == -(5 + 3i) == -5 - 3i 1/a == (5 + 3i).recip == 0.1470588235 - 0.0882352941i a * 1/a == 0.9999999998 Demo 2: other functionality not requested, but important for completeness a + 10 == 10 + a == 15 + 3i 10 - a == -(a - 10) == 5 - 3i a - b == (5 + 3i) - (0.5 + 6i) == 4.5 - 3i 10 * a == a * 10 == 50 + 30i 10 / a == 1 / (a / 10) == 1.4705882350 - 0.8823529410i a / b == (5 + 3i) / (0.5 + 6i) == 0.5655172413793104 - 0.7862068965517242i a ** 2 == a * a == 16.000000000000004 + 30.000000000000007i 0.9 ** b == 0.7653514303676113 - 0.5605686291920475i a ** b == (5 + 3i) ** (0.5 + 6i) == -0.013750112198456855 - 0.09332524760169053i a.real == 5 a.imag == 3 |a| == 5.830951894845301 a.rho == 5.830951894845301 a.ρ == 5.830951894845301 a.theta == 0.5404195002705842 a.θ == 0.5404195002705842 ~a (conjugate) == 5 - 3i ρ*cos(θ) + i*ρ*sin(θ) == 10*cos(π/3) + i*10*sin(π/3) == 10*0.5 + i*10*√(3/4) == 5.000000000000001 + 8.660254037844386i ρ*exp(i*θ) == 10*exp(i*π/3) == 5.000000000000001 + 8.660254037844386i ## Haskell Complex numbers are parameterized in their base type, so you can have Complex Integer for the Gaussian Integers, Complex Float, Complex Double, etc. The operations are just the usual overloaded numeric operations. import Data.Complex main = do let a = 1.0 :+ 2.0 -- complex number 1+2i let b = 4 -- complex number 4+0i -- 'b' is inferred to be complex because it's used in -- arithmetic with 'a' below. putStrLn$ "Add:      " ++ show (a + b)  putStrLn $"Subtract: " ++ show (a - b) putStrLn$ "Multiply: " ++ show (a * b)  putStrLn $"Divide: " ++ show (a / b) putStrLn$ "Negate:   " ++ show (-a)  putStrLn $"Inverse: " ++ show (recip a) putStrLn$ "Conjugate:" ++ show (conjugate a)
Output:
*Main> main
Subtract: (-3.0) :+ 2.0
Multiply: 4.0 :+ 8.0
Divide:   0.25 :+ 0.5
Negate:   (-1.0) :+ (-2.0)
Inverse:  0.2 :+ (-0.4)
Conjugate:1.0 :+ (-2.0)

## Icon and Unicon

 This example is in need of improvement: This could be better implemented as an object i n Unicon. Note, however, that Unicon doesn't allow for operator overloading at the current time.

Icon doesn't provide native support for complex numbers. Support is included in the IPL.

procedure main() SetupComplex()a := complex(1,2)   b := complex(3,4) c := complex(&pi,1.5)d := complex(1)e := complex(,1) every v := !"abcde" do write(v," := ",cpxstr(variable(v))) write("a+b := ", cpxstr(cpxadd(a,b)))write("a-b := ", cpxstr(cpxsub(a,b)))write("a*b := ", cpxstr(cpxmul(a,b)))write("a/b := ", cpxstr(cpxdiv(a,b)))write("neg(a) := ", cpxstr(cpxneg(a)))write("inv(a) := ", cpxstr(cpxinv(a)))write("conj(a) := ", cpxstr(cpxconj(a)))write("abs(a) := ", cpxabs(a))write("neg(1) := ", cpxstr(cpxneg(1)))end

Icon doesn't allow for operator overloading but procedures can be overloaded as was done here to allow 'complex' to behave more robustly.

provides complex number support supplemented by the code below.

 link complex                            # for complex number support procedure SetupComplex()                #: used to setup safe complexCOMPLEX()				#  replace complex record constructor	SetupComplex := 1                       #  never call here againreturnend procedure COMPLEX(rpart,ipart)          #: new safe record constructor and coercioninitial complex :=: COMPLEX             # get in front of record constructorreturn if /ipart & (type(rpart) == "complex")    then rpart                           #                  already complex   else COMPLEX( real(\rpart | 0.0), real(\ipart|0) )    # create a new complex numberend         procedure cpxneg(z)                     #: negate z   z := complex(z)                      # coerce   return complex( -z.rpart, -z.ipart)end procedure cpxinv(z)                     #: inverse of z   local denom   z := complex(z)                      # coerce    denom := z.rpart ^ 2 + z.ipart ^ 2   return complex(z.rpart / denom, z.ipart / denom)end

To take full advantage of the overloaded 'complex' procedure, the other cpxxxx procedures would need to be rewritten or overloaded.

Output:
#complexdemo.exe

a := (1.0+2.0i)
b := (3.0+4.0i)
c := (3.141592653589793+1.5i)
d := (1.0+0.0i)
e := (0.0+1.0i)
a+b := (4.0+6.0i)
a-b := (-2.0-2.0i)
a*b := (-5.0+10.0i)
a/b := (0.44+0.08i)
neg(a) := (-1.0-2.0i)
inv(a) := (0.2+0.4i)
conj(a) := (1.0-2.0i)
abs(a) := 2.23606797749979
neg(1) := (-1.0+0.0i)

## IDL

complex (and dcomplex for double-precision) is a built-in data type in IDL:

x=complex(1,1) y=complex(!pi,1.2) print,x+y(      4.14159,      2.20000) print,x*y(      1.94159,     4.34159) print,-x(     -1.00000,     -1.00000) print,1/x(     0.500000,    -0.500000)

## J

Complex numbers are a native numeric data type in J. Although the examples shown here are performed on scalars, all numeric operations naturally apply to arrays of complex numbers.

   x=: 1j1   y=: 3.14159j1.2   x+y            NB. addition4.14159j2.2   x*y            NB. multiplication1.94159j4.34159   %x             NB. inversion0.5j_0.5   -x             NB. negation_1j_1   +x             NB. (complex) conjugation1j_1

## Java

public class Complex {    public final double real;    public final double imag;     public Complex() {        this(0, 0);    }     public Complex(double r, double i) {        real = r;        imag = i;    }     public Complex add(Complex b) {        return new Complex(this.real + b.real, this.imag + b.imag);    }     public Complex mult(Complex b) {        // FOIL of (a+bi)(c+di) with i*i = -1        return new Complex(this.real * b.real - this.imag * b.imag,                this.real * b.imag + this.imag * b.real);    }     public Complex inv() {        // 1/(a+bi) * (a-bi)/(a-bi) = 1/(a+bi) but it's more workable        double denom = real * real + imag * imag;        return new Complex(real / denom, -imag / denom);    }     public Complex neg() {        return new Complex(-real, -imag);    }     public Complex conj() {        return new Complex(real, -imag);    }     @Override    public String toString() {        return real + " + " + imag + " * i";    }     public static void main(String[] args) {        Complex a = new Complex(Math.PI, -5); //just some numbers        Complex b = new Complex(-1, 2.5);        System.out.println(a.neg());        System.out.println(a.add(b));        System.out.println(a.inv());        System.out.println(a.mult(b));        System.out.println(a.conj());    }}

## JavaScript

function Complex(r, i) {	this.r = r;	this.i = i;} Complex.add = function() {	var num = arguments[0]; 	for(var i = 1, ilim = arguments.length; i < ilim; i += 1){		num.r += arguments[i].r;		num.i += arguments[i].i;	} 	return num;} Complex.multiply = function() {	var num = arguments[0]; 	for(var i = 1, ilim = arguments.length; i < ilim; i += 1){		num.r = (num.r * arguments[i].r) - (num.i * arguments[i].i);		num.i = (num.i * arguments[i].r) - (num.r * arguments[i].i);	} 	return num;} Complex.negate = function (z) {	return new Complex(-1*z.r, -1*z.i);} Complex.invert = function(z) {	var denom = Math.pow(z.r,2) + Math.pow(z.i,2);	return new Complex(z.r/denom, -1*z.i/denom);} Complex.conjugate = function(z) {	return new Complex(z.r, -1*z.i);} // BONUSES!  Complex.prototype.toString = function() {	return this.r === 0 && this.i === 0          ? "0"          : (this.r !== 0 ? this.r : "")           + ((this.r !== 0 || this.i < 0) && this.i !== 0               ? (this.i > 0 ? "+" : "-")               : "" ) + ( this.i !== 0 ? Math.abs(this.i) + "i" : "" ); } Complex.prototype.getMod = function() {	return Math.sqrt( Math.pow(this.r,2) , Math.pow(this.i,2) )}

## jq

For speed and for conformance with the complex plane interpretation, x+iy is represented as [x,y]; for flexibility, all the functions defined here will accept both real and complex numbers; and for uniformity, they are implemented as functions that ignore their input.

Recent versions of jq support modules, so these functions could all be placed in a module to avoid name conflicts, and thus no special prefix is used here.
def real(z): if (z|type) == "number" then z else z[0] end; def imag(z): if (z|type) == "number" then 0 else z[1] end; def plus(x; y):    if (x|type) == "number" then       if  (y|type) == "number" then [ x+y, 0 ]       else [ x + y[0], y[1]]       end    elif (y|type) == "number" then plus(y;x)    else [ x[0] + y[0], x[1] + y[1] ]    end; def multiply(x; y):    if (x|type) == "number" then       if  (y|type) == "number" then [ x*y, 0 ]       else [x * y[0], x * y[1]]       end    elif (y|type) == "number" then multiply(y;x)    else [ x[0] * y[0] - x[1] * y[1],           x[0] * y[1] + x[1] * y[0]]    end; def multiply: reduce .[] as $x (1; multiply(.;$x)); def negate(x): multiply(-1; x); def minus(x; y): plus(x; multiply(-1; y)); def conjugate(z):  if (z|type) == "number" then [z, 0]  else  [z[0], -(z[1]) ]  end; def invert(z):  if (z|type) == "number" then [1/z, 0]  else    ( (z[0] * z[0]) + (z[1] * z[1]) ) as $d # use "0 + ." to convert -0 back to 0 | [ z[0]/$d, (0 + -(z[1]) / $d)] end; def divide(x;y): multiply(x; invert(y)); def exp(z): def expi(x): [ (x|cos), (x|sin) ]; if (z|type) == "number" then z|exp elif z[0] == 0 then expi(z[1]) # for efficiency else multiply( (z[0]|exp); expi(z[1]) ) end ; def test(x;y): "x = \( x )", "y = \( y )", "x+y: \( plus(x;y))", "x*y: \( multiply(x;y))", "-x: \( negate(x))", "1/x: \( invert(x))", "conj(x): \( conjugate(x))", "(x/y)*y: \( multiply( divide(x;y) ; y) )", "e^iπ: \( exp( [0, 4 * (1|atan) ] ) )"; test( [1,1]; [0,1] ) Output: $ jq -n -f complex.jq"x =      [1,1]""y =      [0,1]""x+y:     [1,2]""x*y:     [-1,1]""-x:      [-1,-1]""1/x:     [0.5,-0.5]""conj(x): [1,-1]""(x/y)*y: [1,1]""e^iπ:    [-1,1.2246467991473532e-16]"

## Julia

Julia has built-in support for complex arithmetic with arbitrary real types.

julia> z1 = 1.5 + 3imjulia> z2 = 1.5 + 1.5imjulia> z1 + z23.0 + 4.5imjulia> z1 - z20.0 + 1.5imjulia> z1 * z2-2.25 + 6.75imjulia> z1 / z21.5 + 0.5imjulia> - z1-1.5 - 3.0imjulia> conj(z1), z1'   # two ways to conjugate(1.5 - 3.0im,1.5 - 3.0im)julia> abs(z1)3.3541019662496847julia> z1^z2-1.102482955327779 - 0.38306415117199305imjulia> real(z1)1.5julia> imag(z1)3.0

## Lua

  --defines addition, subtraction, negation, multiplication, division, conjugation, norms, and a conversion to strgs.complex = setmetatable({__add = function(u, v) return complex(u.real + v.real, u.imag + v.imag) end,__sub = function(u, v) return complex(u.real - v.real, u.imag - v.imag) end,__mul = function(u, v) return complex(u.real * v.real - u.imag * v.imag, u.real * v.imag + u.imag * v.real) end,__div = function(u, v) return u * complex(v.real / v.norm, -v.imag / v.norm) end,__unm = function(u) return complex(-u.real, -u.imag) end,__concat = function(u, v)    if type(u) == "table" then return u.real .. " + " .. u.imag .. "i" .. v	elseif type(u) == "string" or type(u) == "number" then return u .. v.real .. " + " .. v.imag .. "i"	end end,__index = function(u, index)  local operations = {    norm = function(u) return u.real ^ 2 + u.imag ^ 2 end,    conj = function(u) return complex(u.real, -u.imag) end,  }  return operations[index] and operations[index](u)end,__newindex = function() error() end}, {__call = function(z, realpart, imagpart) return setmetatable({real = realpart, imag = imagpart}, complex) end} ) local i, j = complex(2, 3), complex(1, 1) print(i .. " + " .. j .. " = " .. (i+j))print(i .. " - " .. j .. " = " .. (i-j))print(i .. " * " .. j .. " = " .. (i*j))print(i .. " / " .. j .. " = " .. (i/j))print("|" .. i .. "| = " .. math.sqrt(i.norm))print(i .. "* = " .. i.conj)

## Maple

Maple has I (the square root of -1) built-in. Thus:

x := 1+I;y := Pi+I*1.2;

By itself, it will perform mathematical operations symbolically, i.e. it will not try to perform computational evaluation unless specifically asked to do so. Thus:

x*y;    ==> (1 + I) (Pi + 1.2 I)simplify(x*y);    ==> 1.941592654 + 4.341592654 I

x+y;x*y;-x;1/x;

## Mathematica / Wolfram Language

Mathematica has fully implemented support for complex numbers throughout the software. Addition, subtraction, division, multiplications and powering need no further syntax than for real numbers:

x=1+2Iy=3+4I x+y  =>  4 + 6 Ix-y  =>  -2 - 2 Iy x  =>  -5 + 10 Iy/x  => 11/5 - (2 I)/5x^3  =>  -11 - 2 Iy^4  =>  -527 - 336 Ix^y  =>  (1 + 2 I)^(3 + 4 I)    N[x^y]  =>  0.12901 + 0.0339241 I

Powering to a complex power can in general not be written shorter, so Mathematica leaves it unevaluated if the numbers are exact. An approximation can be acquired using the function N. However Mathematica goes much further, basically all functions can handle complex numbers to arbitrary precision, including (but not limited to!):

Exp  LogSin  Cos  Tan  Csc  Sec  CotArcSin  ArcCos  ArcTan  ArcCsc  ArcSec  ArcCotSinh  Cosh  Tanh  Csch  Sech  CothArcSinh  ArcCosh  ArcTanh  ArcCsch  ArcSech  ArcCothSincHaversine  InverseHaversine Factorial  Gamma  PolyGamma  LogGammaErf  BarnesG  Hyperfactorial  Zeta  ProductLog  RamanujanTauL

and many many more. The documentation states:

Mathematica has fundamental support for both explicit complex numbers and symbolic complex variables. All applicable mathematical functions support arbitrary-precision evaluation for complex values of all parameters, and symbolic operations automatically treat complex variables with full generality.

## MATLAB

Complex numbers are a primitive data type in MATLAB. All the typical complex operations can be performed. There are two keywords that specify a number as complex: "i" and "j".

>> a = 1+i a =   1.000000000000000 + 1.000000000000000i >> b = 3+7i b =   3.000000000000000 + 7.000000000000000i >> a+b ans =   4.000000000000000 + 8.000000000000000i >> a-b ans =  -2.000000000000000 - 6.000000000000000i >> a*b ans =  -4.000000000000000 +10.000000000000000i >> a/b ans =   0.172413793103448 - 0.068965517241379i >> -a ans =  -1.000000000000000 - 1.000000000000000i >> a' ans =   1.000000000000000 - 1.000000000000000i >> a^b ans =   0.000808197112874 - 0.011556516327187i >> norm(a) ans =    1.414213562373095

## Maxima

z1: 5 + 2 * %i;2*%i+5 z2: 3 - 7 * %i;3-7*%i carg(z1);atan(2/5) cabs(z1);sqrt(29) rectform(z1 * z2);29-29*%i polarform(z1);sqrt(29)*%e^(%i*atan(2/5)) conjugate(z1);5-2*%i z1 + z2;8-5*%i z1 - z2;9*%i+2 z1 * z2;(3-7*%i)*(2*%i+5) z1 * z2, rectform;29-29*%i z1 / z2;(2*%i+5)/(3-7*%i) z1 / z2, rectform;(41*%i)/58+1/58 realpart(z1);5 imagpart(z1);2

## МК-61/52

Instrustion:

Z1 = a + ib; Z2 = c + id;

a С/П b С/П c С/П d С/П

Division: С/П; multiplication: БП 36 С/П; addition: БП 54 С/П; subtraction: БП 63 С/П.

ПA	С/П	ПB	С/П	ПC	С/П	ПD	С/П	ИПC	x^2ИПD	x^2	+	П3	ИПA	ИПC	*	ИПB	ИПD	*+	ИП3	/	П1	ИПB	ИПC	*	ИПA	ИПD	*-	ИП3	/	П2	ИП1	С/П	ИПA	ИПC	*	ИПBИПD	*	-	П1	ИПB	ИПC	*	ИПA	ИПD	*+	П2	ИП1	С/П	ИПB	ИПD	+	П2	ИПA	ИПC+	ИП1	С/П	ИПB	ИПD	-	П2	ИПA	ИПC	-П1	С/П

## Modula-2

MODULE complex; IMPORT  InOut; TYPE    Complex         = RECORD   R, Im    : REAL    END; VAR     z               : ARRAY [0..3] OF Complex; PROCEDURE ShowComplex (str  : ARRAY OF CHAR;  p  : Complex); BEGIN  InOut.WriteString (str);              InOut.WriteString (" = ");  InOut.WriteReal (p.R, 6, 2);  IF  p.Im >= 0.0  THEN  InOut.WriteString (" + ")  ELSE  InOut.WriteString (" - ")  END;  InOut.WriteReal (ABS (p.Im), 6, 2);   InOut.WriteString (" i ");  InOut.WriteLn;                        InOut.WriteBfEND ShowComplex; PROCEDURE AddComplex (x1, x2 : Complex; VAR x3  : Complex); BEGIN  x3.R  := x1.R  + x2.R;  x3.Im := x1.Im + x2.ImEND AddComplex; PROCEDURE SubComplex (x1, x2 : Complex; VAR x3  : Complex); BEGIN  x3.R := x1.R - x2.R;  x3.Im := x1.Im - x2.ImEND SubComplex; PROCEDURE MulComplex (x1, x2  : Complex; VAR x3  : Complex); BEGIN  x3.R := x1.R * x2.R - x1.Im * x2.Im;  x3.Im := x1.R * x2.Im + x1.Im * x2.REND MulComplex; PROCEDURE InvComplex (x1 : Complex; VAR x2  : Complex); BEGIN  x2.R := x1.R / (x1.R * x1.R + x1.Im * x1.Im);  x2.Im := -1.0 * x1.Im / (x1.R * x1.R + x1.Im * x1.Im)END InvComplex; PROCEDURE NegComplex (x1 : Complex; VAR x2  : Complex); BEGIN  x2.R := - x1.R;       x2.Im := - x1.ImEND NegComplex; BEGIN  InOut.WriteString ("Enter two complex numbers : ");  InOut.WriteBf;  InOut.ReadReal (z[0].R);              InOut.ReadReal (z[0].Im);  InOut.ReadReal (z[1].R);              InOut.ReadReal (z[1].Im);  ShowComplex ("z1", z[0]);             ShowComplex ("z2", z[1]);  InOut.WriteLn;  AddComplex (z[0], z[1], z[2]);        ShowComplex ("z1 + z2", z[2]);  SubComplex (z[0], z[1], z[2]);        ShowComplex ("z1 - z2", z[2]);  MulComplex (z[0], z[1], z[2]);        ShowComplex ("z1 * z2", z[2]);  InvComplex (z[0], z[2]);              ShowComplex ("1  / z1", z[2]);  NegComplex (z[0], z[2]);              ShowComplex ("   - z1", z[2]);  InOut.WriteLnEND complex.
Output:
Enter two complex numbers : 5 3 0.5 6
z1 =   5.00 +   3.00 i
z2 =   0.50 +   6.00 i

z1 + z2 =   5.50 +   9.00 i
z1 - z2 =   4.50 -   3.00 i
z1 * z2 = -15.50 +  31.50 i
1  / z1 =   0.15 -   0.09 i
- z1 =  -5.00 -   3.00 i

## Nanoquery

Translation of: Java

This is a translation of the Java version, but it uses operator redefinition where possible.

import math class Complex        declare real        declare imag         def Complex()                real = 0.0                imag = 0.0        end         def Complex(r, i)                real = double(r)                imag = double(i)        end         def operator-(b)                return new(Complex, this.real - b.real, this.imag - b.imag)        end         def operator+(b)                return new(Complex, this.real + b.real, this.imag + b.imag)        end         def operator*(b)                // FOIL of (a+bi)(c+di) with i*i = -1                return new(Complex, this.real * b.real - this.imag * b.imag,\                         this.real * b.imag + this.imag * b.real)        end         def inv()                // 1/(a+bi) * (a-bi)/(a-bi) = 1/(a+bi) but it's more workable                denom = this.real * this.real + this.imag * this.imag                return new(Complex, real/denom, -imag/denom)        end         def neg()                return new(Complex, -this.real, -this.imag)        end         def conj()                return new(Complex, this.real, -this.imag)        end         def toString()                return this.real + " + " + this.imag + " * i"        endend a = new(Complex, math.pi, -5)b = new(Complex, -1, 2.5)println a.neg()println a + bprintln a.inv()println a * bprintln a.conj()

## Nemerle

using System;using System.Console;using System.Numerics;using System.Numerics.Complex; module RCComplex{    PrettyPrint(this c : Complex) : string    {        mutable sign = '+';        when (c.Imaginary < 0) sign = '-';        $"$(c.Real) $sign$(Math.Abs(c.Imaginary))i"    }     Main() : void    {        def complex1 = Complex(1.0, 1.0);        def complex2 = Complex(3.14159, 1.2);         WriteLine(Add(complex1, complex2).PrettyPrint());        WriteLine(Multiply(complex1, complex2).PrettyPrint());        WriteLine(Negate(complex2).PrettyPrint());        WriteLine(Reciprocal(complex2).PrettyPrint());        WriteLine(Conjugate(complex2).PrettyPrint());    }}
Output:
4.14159 + 2.2i
1.94159 + 4.34159i
-3.14159 - 1.2i
0.277781124787984 - 0.106104663481097i
3.14159 - 1.2i

## Nim

 import complexvar a: Complex = (1.0,1.0)var b: Complex = (3.1415,1.2) echo("a    : " & $a)echo("b : " &$b)echo("a + b: " & $(a + b))echo("a * b: " &$(a * b))echo("1/a  : " & $(1/a))echo("-a : " &$(-a))
Output:
a    : (1.0000000000000000e+00, 1.0000000000000000e+00)
b    : (3.1415000000000002e+00, 1.2000000000000000e+00)
a + b: (4.1415000000000006e+00, 2.2000000000000002e+00)
a * b: (1.9415000000000002e+00, 4.3414999999999999e+00)
1/a  : (5.0000000000000000e-01, -5.0000000000000000e-01)
-a   : (-1.0000000000000000e+00, -1.0000000000000000e+00)


## Oberon-2

Oxford Oberon Compiler

 MODULE Complex;IMPORT Files,Out;TYPE        Complex* = POINTER TO ComplexDesc;        ComplexDesc = RECORD                r-,i-: REAL;        END; PROCEDURE (CONST x: Complex) Add*(CONST y: Complex): Complex;BEGIN        RETURN New(x.r + y.r,x.i + y.i)END Add; PROCEDURE (CONST x: Complex) Sub*(CONST y: Complex): Complex;BEGIN        RETURN New(x.r - y.r,x.i - y.i)END Sub; PROCEDURE (CONST x: Complex) Mul*(CONST y: Complex): Complex;BEGIN        RETURN New(x.r*y.r - x.i*y.i,x.r*y.i + x.i*y.r)END Mul; PROCEDURE (CONST x: Complex) Div*(CONST y: Complex): Complex;VAR        d: REAL;BEGIN        d := y.r * y.r + y.i * y.i;        RETURN New((x.r*y.r + x.i*y.i)/d,(x.i*y.r - x.r*y.i)/d)END Div; (* Reciprocal *)PROCEDURE (CONST x: Complex) Rec*(): Complex;VAR        d: REAL;BEGIN        d := x.r * x.r + y.i * y.i;        RETURN New(x.r/d,(-1.0 * x.i)/d);END Rec; (* Conjugate *)PROCEDURE (x: Complex) Con*(): Complex;BEGIN        RETURN New(x.r, (-1.0) * x.i);END Con; PROCEDURE (x: Complex) Out(out : Files.File);BEGIN        Files.WriteString(out,"(");        Files.WriteReal(out,x.r);        Files.WriteString(out,",");        Files.WriteReal(out,x.i);        Files.WriteString(out,"i)")END Out; PROCEDURE New(x,y: REAL): Complex;VAR        r: Complex;BEGIN        NEW(r);r.r := x;r.i := y;        RETURN rEND New; VAR        r,x,y: Complex;BEGIN        x := New(1.5,3);        y := New(1.0,1.0);         Out.String("x: ");x.Out(Files.stdout);Out.Ln;        Out.String("y: ");y.Out(Files.stdout);Out.Ln;                r := x.Add(y);        Out.String("x + y: ");r.Out(Files.stdout);Out.Ln;        r := x.Sub(y);        Out.String("x - y: ");r.Out(Files.stdout);Out.Ln;        r := x.Mul(y);        Out.String("x * y: ");r.Out(Files.stdout);Out.Ln;        r := x.Div(y);        Out.String("x / y: ");r.Out(Files.stdout);Out.Ln;        r := y.Rec();        Out.String("1 / y: ");r.Out(Files.stdout);Out.Ln;        r := x.Con();        Out.String("x': ");r.Out(Files.stdout);Out.Ln; END Complex.
Output:
x: (1.50000,3.00000i)
y: (1.00000,1.00000i)
x + y: (2.50000,4.00000i)
x - y: (0.500000,2.00000i)
x * y: (-1.50000,4.50000i)
x / y: (2.25000,0.750000i)
1 / y: (0.500000,-0.500000i)
x': (1.50000,-3.00000i)


## OCaml

The Complex module from the standard library provides the functionality of complex numbers:

open Complex let print_complex z =  Printf.printf "%f + %f i\n" z.re z.im let () =  let a = { re = 1.0; im = 1.0 }  and b = { re = 3.14159; im = 1.25 } in  print_complex (add a b);  print_complex (mul a b);  print_complex (inv a);  print_complex (neg a);  print_complex (conj a)

let () =  Complex.(    let print txt z = Printf.printf "%s = %s\n" txt (to_string z) in    let a = 1 + I    and b = 3 + 7I in    print "a + b" (a + b);    print "a - b" (a - b);    print "a * b" (a * b);    print "a / b" (a / b);    print "-a" (- a);    print "conj a" (conj a);    print "a^b" (a**b);    Printf.printf "norm a = %g\n" (float(abs a));  )

## Octave

GNU Octave handles naturally complex numbers:

z1 = 1.5 + 3i;z2 = 1.5 + 1.5i;disp(z1 + z2);    % 3.0 + 4.5idisp(z1 - z2);    % 0.0 + 1.5idisp(z1 * z2);    % -2.25 + 6.75idisp(z1 / z2);    % 1.5 + 0.5idisp(-z1);        % -1.5 - 3idisp(z1');        % 1.5 - 3idisp(abs(z1));    % 3.3541 = sqrt(z1*z1')disp(z1 ^ z2);    % -1.10248 - 0.38306idisp( exp(z1) );  % -4.43684 + 0.63246idisp( imag(z1) ); % 3disp( real(z2) ); % 1.5%...

## Oforth

Object Class new: Complex(re, im) Complex method: re  @re ;Complex method: im  @im ; Complex method: initialize   := im := re ;Complex method: <<  '(' <<c @re << ',' <<c @im << ')' <<c  ; 0 1 Complex new const: I Complex method: ==(c -- b )    c re @re == c im @im == and ; Complex method: norm -- f     @re sq @im sq + sqrt ; Complex method: conj -- c    @re @im neg Complex new ; Complex method: +(c -- d )    c re @re +  c im @im + Complex new ; Complex method: -(c -- d )       c re @re -  c im @im - Complex new ; Complex method: *(c -- d)      c re @re * c im @im * -  c re @im * @re c im * + Complex new ; Complex method: inv  | n |   @re sq @im sq + >float ->n   @re n /   @im neg n / Complex new; Complex method: /( c -- d )   c self inv * ; Integer method: >complex  self 0 Complex new ;Float   method: >complex  self 0 Complex new ;

Usage :

3.2 >complex I * 2 >complex + .cr2 3 Complex new  1.2 >complex + .cr2 3 Complex new  1.2 >complex * .cr2 >complex  2 3 Complex new / .cr
Output:
(2,3.2)
(3.2,3)
(2.4,3.6)
(0.307692307692308,-0.461538461538462)


## Ol

Ol supports complex numbers by default. Numbers must be entered manually in form A+Bi without spaces between elements, where A and B - numbers (can be rational), i - imaginary unit; or in functional form using function complex.

 (define A 0+1i) ; manually entered numbers(define B 1+0i) (print (+ A B)); <== 1+i (print (- A B)); <== -1+i (print (* A B)); <== 0+i (print (/ A B)); <== 0+i  (define C (complex 2/7 -3)) ; functional way (print "real part of " C " is " (car C)); <== real part of 2/7-3i is 2/7 (print "imaginary part of " C " is " (cdr C)); <== imaginary part of 2/7-3i is -3

## ooRexx

c1 = .complex~new(1, 2)c2 = .complex~new(3, 4)r = 7 say "c1           =" c1say "c2           =" c2say "r            =" rsay "-c1          =" (-c1)say "c1 + r       =" c1 + rsay "c1 + c2      =" c1 + c2say "c1 - r       =" c1 - rsay "c1 - c2      =" c1 - c2say "c1 * r       =" c1 * rsay "c1 * c2      =" c1 * c2say "inv(c1)      =" c1~invsay "conj(c1)     =" c1~conjugatesay "c1 / r       =" c1 / rsay "c1 / c2      =" c1 / c2say "c1 == c1     =" (c1 == c1)say "c1 == c2     =" (c1 == c2)  ::class complex::method init  expose r i  use strict arg r, i = 0 -- complex instances are immutable, so these are-- read only attributes::attribute r GET::attribute i GET ::method negative  expose r i  return self~class~new(-r, -i) ::method add  expose r i  use strict arg other  if other~isa(.complex) then     return self~class~new(r + other~r, i + other~i)  else return self~class~new(r + other, i) ::method subtract  expose r i  use strict arg other  if other~isa(.complex) then     return self~class~new(r - other~r, i - other~i)  else return self~class~new(r - other, i) ::method times  expose r i  use strict arg other  if other~isa(.complex) then     return self~class~new(r * other~r - i * other~i, r * other~i + i * other~r)  else return self~class~new(r * other, i * other) ::method inv  expose r i  denom = r * r + i * i  return self~class~new(r/denom,-i/denom) ::method conjugate  expose r i  return self~class~new(r, -i) ::method divide  use strict arg other  -- this is easier if everything is a complex number  if \other~isA(.complex) then other = .complex~new(other)  -- division is multiplication with the inversion  return self * other~inv ::method "=="  expose r i  use strict arg other   if \other~isa(.complex) then return .false  -- Note:  these are numeric comparisons, so we're using the "="  -- method so those are handled correctly  return r = other~r & i = other~i ::method "\=="  use strict arg other  return \self~"\=="(other) ::method "="  -- this is equivalent of "=="  forward message("==") ::method "\="  -- this is equivalent of "\=="  forward message("\==") ::method "<>"  -- this is equivalent of "\=="  forward message("\==") ::method "><"  -- this is equivalent of "\=="  forward message("\==") -- some operator overrides -- these only work if the left-hand-side of the-- subexpression is a quaternion::method "*"  forward message("TIMES") ::method "/"  forward message("DIVIDE") ::method "-"  -- need to check if this is a prefix minus or a subtract  if arg() == 0 then      forward message("NEGATIVE")  else      forward message("SUBTRACT") ::method "+"  -- need to check if this is a prefix plus or an addition  if arg() == 0 then      return self  -- we can return this copy since it is immutable  else      forward message("ADD") ::method string  expose r i  return r self~formatnumber(i)"i" ::method formatnumber private  use arg value  if value > 0 then return "+" value  else return "-" value~abs -- override hashcode for collection class hash uses::method hashCode  expose r i  return r~hashcode~bitxor(i~hashcode)
Output:
c1           = 1 + 2i
c2           = 3 + 4i
r            = 7
-c1          = -1 - 2i
c1 + r       = 8 + 2i
c1 + c2      = 4 + 6i
c1 - r       = -6 + 2i
c1 - c2      = -2 - 2i
c1 * r       = 7 + 14i
c1 * c2      = -5 + 10i
inv(c1)      = 0.2 - 0.4i
conj(c1)     = 1 - 2i
c1 / r       = 0.142857143 + 0.285714286i
c1 / c2      = 0.44 + 0.08i
c1 == c1     = 1
c1 == c2     = 0

## OxygenBasic

Implementation of a complex numbers class with arithmetical operations, and powers using DeMoivre's theorem (polar conversion).

 'COMPLEX OPERATIONS'================= type tcomplex double x,y class Complex'============   has tcomplex  static sys i,pp  static tcomplex accum[32] def operands  tcomplex*a,*b  @[email protected]+i  if pp then    @[email protected]+sizeof accum    pp=0  else    @[email protected]  end ifend def method "load"()  operands  a.x=b.x  a.y=b.yend method method "push"()  i+=sizeof accumend method method "pop"()  pp=1  i-=sizeof accumend method method "="()  operands  b.x=a.x  b.y=a.yend method method "+"()  operands  a.x+=b.x  a.y+=b.yend method method "-"()  operands  a.x-=b.x  a.y-=b.yend method method "*"()  operands  double d  d=a.x  a.x = a.x * b.x - a.y * b.y  a.y = a.y * b.x + d   * b.yend method method "/"()  operands  double d,v  v=1/(b.x * b.x + b.y * b.y)  d=a.x  a.x = (a.x * b.x + a.y * b.y) * v  a.y = (a.y * b.x - d   * b.y) * vend method method power(double n)  operands  'Using DeMoivre theorem  double r,an,mg  r = hypot(b.x,b.y)  mg = r^n  if b.x=0 then    ay=.5*pi    if b.y<0 then ay=-ay  else    an = atan(b.y,b.x)  end if  an  *= n   a.x  = mg * cos(an)  a.y  = mg * sin(an)end method method show() as string  return str(x,14) ", " str(y,14)end method end class '#recordof complexop   '===='TEST'==== complex z1,z2,z3,z4,z5 'ENTER VALUES z1 <=  0, 0z2 <=  2, 1z3 <= -2, 1z4 <=  2, 4z5 <=  1, 1 'EVALUATE COMPLEX EXPRESSIONS z1 =  z2 * z3print "Z1 = "+z1.show 'RESULT  -5.0, 0 z1 = z3+(z2.power(2))print "Z1 = "+z1.show  'RESULT  1.0, 5.0  z1 = z5/z4print "Z1 = "+z1.show  'RESULT 0.3, 0.1 z1 = z5/z1print "Z1 = "+z1.show  'RESULT 2.0, 4.0 z1 = z2/z4print "Z1 = "+z1.show  'RESULT  -0.4, -0.3 z1 = z1*z4print "Z1 = "+z1.show  'RESULT  2.0, 1.0

## PARI/GP

To use, type, e.g., inv(3 + 7*I).

add(a,b)=a+b;mult(a,b)=a*b;neg(a)=-a;inv(a)=1/a;

## Pascal

Works with: Extended Pascal

The simple data type complex is part of Extended Pascal, ISO standard 10206.

program complexDemo(output); const	{ I experienced some hiccups with -1.0 using GPC (GNU Pascal Compiler) }	negativeOne = -1.0; type	line = string(80); { as per task requirements wrap arithmetic operations into separate functions }function sum(protected x, y: complex): complex;begin	sum := x + yend; function product(protected x, y: complex): complex;begin	product := x * yend; function negative(protected x: complex): complex;begin	negative := -xend; function inverse(protected x: complex): complex;begin	inverse := x ** negativeOneend; { only this function is not covered by Extended Pascal, ISO 10206 }function conjugation(protected x: complex): complex;begin	conjugation := cmplx(re(x), im(x) * negativeOne)end; { --- test suite ------------------------------------------------------------- }function asString(protected x: complex): line;const	totalWidth = 5;	fractionDigits = 2;var	result: line;begin	writeStr(result, '(', re(x):totalWidth:fractionDigits, ', ',		im(x):totalWidth:fractionDigits, ')');	asString := resultend; { === MAIN =================================================================== }var	x: complex;	{ for demonstration purposes: how to initialize complex variables }	y: complex value cmplx(1.0, 4.0);	z: complex value polar(exp(1.0), 3.14159265358979);begin	x := cmplx(-3, 2); 	writeLn(asString(x), ' + ', asString(y), ' = ', asString(sum(x, y)));	writeLn(asString(x), ' * ', asString(z), ' = ', asString(product(x, z))); 	writeLn; 	writeLn('               −', asString(z), '  = ', asString(negative(z)));	writeLn('        inverse(', asString(z), ') = ', asString(inverse(z)));	writeLn('    conjugation(', asString(y), ') = ', asString(conjugation(y)));end.
Output:
(-3.00,  2.00) + ( 1.00,  4.00) = (-2.00,  6.00)
(-3.00,  2.00) * (-2.72,  0.00) = ( 8.15, -5.44)

−(-2.72,  0.00)  = ( 2.72, -0.00)
inverse((-2.72,  0.00)) = (-0.37, -0.00)
conjugation(( 1.00,  4.00)) = ( 1.00, -4.00)

The PXSC, Pascal eXtensions for scientific computing, define a standard data type similar to Free Pascal’s ucomplex data type.

## Perl

The Math::Complex module implements complex arithmetic.

use Math::Complex;my $a = 1 + 1*i;my$b = 3.14159 + 1.25*i; print "$_\n" foreach$a + $b, # addition$a * $b, # multiplication -$a,        # negation    1 / $a, # multiplicative inverse ~$a;        # complex conjugate

## Phix

-- demo\rosetta\ArithComplex.exwinclude complex.ecomplex a = complex_new(1,1),        b = complex_new(3.14159,1.25),        c = complex_new(1,0),        d = complex_new(0,1)printf(1,"a = %s\n",{complex_sprint(a)})printf(1,"b = %s\n",{complex_sprint(b)})printf(1,"c = %s\n",{complex_sprint(c)})printf(1,"d = %s\n",{complex_sprint(d)})printf(1,"a+b = %s\n",{complex_sprint(complex_add(a,b))})printf(1,"a*b = %s\n",{complex_sprint(complex_mul(a,b))})printf(1,"1/a = %s\n",{complex_sprint(complex_inv(a))})printf(1,"c/a = %s\n",{complex_sprint(complex_div(c,a))})printf(1,"c-a = %s\n",{complex_sprint(complex_sub(c,a))})printf(1,"d-a = %s\n",{complex_sprint(complex_sub(d,a))})printf(1,"-a = %s\n",{complex_sprint(complex_neg(a))})printf(1,"conj a = %s\n",{complex_sprint(complex_conjugate(a))})
Output:
a = 1+i
b = 3.14159+1.25i
c = 1
d = i
a+b = 4.14159+2.25i
a*b = 1.89159+4.39159i
1/a = 0.5-0.5i
c/a = 0.5-0.5i
c-a = -i
d-a = -1
-a = -1-i
conj a = 1-i


## PicoLisp

(load "@lib/math.l") (de addComplex (A B)   (cons      (+ (car A) (car B))        # Real      (+ (cdr A) (cdr B)) ) )    # Imag (de mulComplex (A B)   (cons      (-         (*/ (car A) (car B) 1.0)         (*/ (cdr A) (cdr B) 1.0) )      (+         (*/ (car A) (cdr B) 1.0)         (*/ (cdr A) (car B) 1.0) ) ) ) (de invComplex (A)   (let Denom      (+         (*/ (car A) (car A) 1.0)         (*/ (cdr A) (cdr A) 1.0) )      (cons         (*/ (car A) 1.0 Denom)         (- (*/ (cdr A) 1.0 Denom)) ) ) ) (de negComplex (A)   (cons (- (car A)) (- (cdr A))) ) (de fmtComplex (A)   (pack      (round (car A) (dec *Scl))      (and (gt0 (cdr A)) "+")      (round (cdr A) (dec *Scl))      "i" ) ) (let (A (1.0 . 1.0)  B (cons pi 1.2))   (prinl "A = " (fmtComplex A))   (prinl "B = " (fmtComplex B))   (prinl "A+B = " (fmtComplex (addComplex A B)))   (prinl "A*B = " (fmtComplex (mulComplex A B)))   (prinl "1/A = " (fmtComplex (invComplex A)))   (prinl "-A = " (fmtComplex (negComplex A))) )
Output:
A = 1.00000+1.00000i
B = 3.14159+1.20000i
A+B = 4.14159+2.20000i
A*B = 1.94159+4.34159i
1/A = 0.50000-0.50000i
-A = -1.00000-1.00000i

## PL/I

/* PL/I complex numbers may be integer or floating-point.  *//* In this example, the variables are floating-pint.       *//* For integer variables, change 'float' to 'fixed binary' */ declare (a, b) complex float;a = 2+5i;b = 7-6i; put skip list (a+b);put skip list (a - b);put skip list (a*b);put skip list (a/b);put skip list (a**b);put skip list (1/a);put skip list (conjg(a)); /* gives the conjugate of 'a'. */ /* Functions exist for extracting the real and imaginary parts *//* of a complex number. */ /* As well, trigonometric functions may be used with complex  *//* numbers, such as SIN, COS, TAN, ATAN, and so on.           */

## Pop11

Complex numbers are a built-in data type in Pop11. Real and imaginary part of complex numbers can be floating point or exact (integer or rational) value (both part must be of the same type). Operations on floating point complex numbers always produce complex numbers. Operations on exact complex numbers give real result (integer or rational) if imaginary part of the result is 0. The '+:' and '-:' operators create complex numbers: '1 -: 3' is '1 - 3i' in mathematical notation.

lvars a = 1.0 +: 1.0, b = 2.0 +: 5.0 ;a+b =>a*b =>1/a =>a-b =>a-a =>a/b =>a/a => ;;; The same, but using exact values1 +: 1 -> a;2 +: 5 -> b;a+b =>a*b =>1/a =>a-b =>a-a =>a/b =>a/a =>

## PostScript

Complex numbers can be represented as 2 element vectors ( arrays ). Thus, a+bi can be written as [a b] in PostScript.

 %Adding two complex numbers/addcomp{/x exch def/y exch def/z [0 0] defz 0 x 0 get y 0 get add put z 1 x 1 get y 1 get add putz pstack}def  %Subtracting one complex number from another/subcomp{/x exch def/y exch def/z [0 0] defz 0 x 0 get y 0 get sub put z 1 x 1 get y 1 get sub putz pstack}def %Multiplying two complex numbers/mulcomp{/x exch def/y exch def/z [0 0] defz 0 x 0 get y 0 get mul x 1 get y 1 get mul sub  put z 1 x 1 get y 0 get mul x 0 get y 1 get mul add putz pstack}def %Negating a complex number/negcomp{/x exch def/z [0 0] defz 0 x 0 get neg putz 1 x 1 get neg putz pstack}def %Inverting a complex number/invcomp{/x exch def/z [0 0] defz 0 x 0 get x 0 get 2 exp x 1 get 2 exp add div putz 0 x 1 get neg x 0 get 2 exp x 1 get 2 exp add div putz pstack}def

## PowerShell

### Implementation

 class Complex {  [Double]$x [Double]$y  Complex() {      $this.x = 0$this.y = 0  }  Complex([Double]$x, [Double]$y) {      $this.x =$x      $this.y =$y  }  [Double]abs2() {return $this.x*$this.x + $this.y*$this.y}  [Double]abs() {return [math]::sqrt($this.abs2())} static [Complex]add([Complex]$m,[Complex]$n) {return [Complex]::new($m.x+$n.x,$m.y+$n.y)} static [Complex]mul([Complex]$m,[Complex]$n) {return [Complex]::new($m.x*$n.x -$m.y*$n.y,$m.x*$n.y +$n.x*$m.y)} [Complex]mul([Double]$k) {return [Complex]::new($k*$this.x, $k*$this.y)}  [Complex]negate() {return $this.mul(-1)} [Complex]conjugate() {return [Complex]::new($this.x, -$this.y)} [Complex]inverse() {return$this.conjugate().mul(1/$this.abs2())} [String]show() { if(0 -ge$this.y) {        return "$($this.x)+$($this.y)i"    } else {        return "$($this.x)$($this.y)i"    }  }  static [String]show([Complex]$other) { return$other.show()  }}$m = [complex]::new(3, 4)$n = [complex]::new(7, 6)"$m:$($m.show())""$n: $($n.show())""$m + $n: $([complex]::show([complex]::add($m,$n)))""$m * $n:$([complex]::show([complex]::mul($m,$n)))""negate $m:$($m.negate().show())""1/$m: $([complex]::show($m.inverse()))""conjugate $m:$([complex]::show($m.conjugate()))"  Output: $m: 3+4i
$n: 7+6i$m + $n: 10+10i$m * $n: -3+46i negate$m: -3-4i
1/$m: 0.12-0.16i conjugate$m: 3-4i


### Library

 function show([System.Numerics.Complex]$c) { if(0 -le$c.Imaginary) {        return "$($c.Real)+$($c.Imaginary)i"    } else {        return "$($c.Real)$($c.Imaginary)i"    }  }$m = [System.Numerics.Complex]::new(3, 4)$n = [System.Numerics.Complex]::new(7, 6)"$m:$(show $m)""$n: $(show$n)""$m + $n: $(show ([System.Numerics.Complex]::Add($m,$n)))""$m * $n:$(show ([System.Numerics.Complex]::Multiply($m,$n)))""negate $m:$(show ([System.Numerics.Complex]::Negate($m)))""1/$m: $(show ([System.Numerics.Complex]::Reciprocal($m)))""conjugate $m:$(show ([System.Numerics.Complex]::Conjugate($m)))"  Output: $m: 3+4i
$n: 7+6i$m + $n: 10+10i$m * $n: -3+46i negate$m: -3-4i
1/$m: 0.12-0.16i conjugate$m: 3-4i


Structure Complex  real.d  imag.dEndStructure Procedure Add_Complex(*A.Complex, *B.Complex)   Protected *R.Complex=AllocateMemory(SizeOf(Complex))  If *R    *R\real=*A\real+*B\real    *R\imag=*A\imag+*B\imag  EndIf  ProcedureReturn *REndProcedure Procedure Inv_Complex(*A.Complex)  Protected *R.Complex=AllocateMemory(SizeOf(Complex)), denom.d  If *R    denom  = *A\real * *A\real + *A\imag * *A\imag    *R\real= *A\real / denom    *R\imag=-*A\imag / denom  EndIf  ProcedureReturn *REndProcedure Procedure Mul_Complex(*A.Complex, *B.Complex)  Protected *R.Complex=AllocateMemory(SizeOf(Complex))  If *R    *R\real=*A\real * *B\real - *A\imag * *B\imag    *R\imag=*A\real * *B\imag + *A\imag * *B\real  EndIf  ProcedureReturn *REndProcedure Procedure Neg_Complex(*A.Complex)  Protected *R.Complex=AllocateMemory(SizeOf(Complex))  If *R    *R\real=-*A\real    *R\imag=-*A\imag  EndIf  ProcedureReturn *REndProcedure Procedure ShowAndFree(Header$, *Complex.Complex) If *Complex Protected.d i=*Complex\imag, r=*Complex\real Print(LSet(Header$,7))    Print("= "+StrD(r,3))    If i>=0:  Print(" + ")    Else:     Print(" - ")    EndIf    PrintN(StrD(Abs(i),3)+"i")    FreeMemory(*Complex)  EndIfEndProcedure If OpenConsole()  Define.Complex a, b, *c  a\real=1.0: a\imag=1.0  b\real=#PI: b\imag=1.2  *c=Add_Complex(a,b):  ShowAndFree("a+b",    *c)  *c=Mul_Complex(a,b):  ShowAndFree("a*b",    *c)  *c=Inv_Complex(a):    ShowAndFree("Inv(a)", *c)  *c=Neg_Complex(a):    ShowAndFree("-a",     *c)  Print(#CRLF$+"Press ENTER to exit"):Input()EndIf ## Python >>> z1 = 1.5 + 3j>>> z2 = 1.5 + 1.5j>>> z1 + z2(3+4.5j)>>> z1 - z21.5j>>> z1 * z2(-2.25+6.75j)>>> z1 / z2(1.5+0.5j)>>> - z1(-1.5-3j)>>> z1.conjugate()(1.5-3j)>>> abs(z1)3.3541019662496847>>> z1 ** z2(-1.1024829553277784-0.38306415117199333j)>>> z1.real1.5>>> z1.imag3.0>>>  ## R Translation of: Octave z1 <- 1.5 + 3iz2 <- 1.5 + 1.5iprint(z1 + z2) # 3+4.5i print(z1 - z2) # 0+1.5i print(z1 * z2) # -2.25+6.75i print(z1 / z2) # 1.5+0.5i print(-z1) # -1.5-3i print(Conj(z1)) # 1.5-3i print(abs(z1)) # 3.354102 print(z1^z2) # -1.102483-0.383064i print(exp(z1)) # -4.436839+0.632456i print(Re(z1)) # 1.5 print(Im(z1)) # 3 ## Racket  #lang racket (define a 3+4i)(define b 8+0i) (+ a b) ; addition(- a b) ; subtraction(/ a b) ; division(* a b) ; multiplication(- a) ; negation(/ 1 a) ; reciprocal(conjugate a) ; conjugation  ## Raku (formerly Perl 6) Works with: Rakudo version 2015.12 my$a = 1 + i;my $b = pi + 1.25i; .say for$a + $b,$a * $b, -$a, 1 / $a,$a.conj;.say for $a.abs,$a.sqrt, $a.re,$a.im;
Output:
(precision varies with different implementations):
4.1415926535897931+2.25i
1.8915926535897931+4.3915926535897931i
-1-1i
0.5-0.5i
1-1i
1.4142135623730951
1.0986841134678098+0.45508986056222733i
1
1


## REXX

The REXX language has no complex type numbers, but most complex arithmetic functions can easily be written.

/*REXX program  demonstrates how to support some  math functions  for  complex numbers. */x = '(5,3i)'                                     /*define  X    ─── can use  I i J or j */y = "( .5,  6j)"                                 /*define  Y         "   "   " " "  " " */ say '      addition:   '        x        " + "         y         ' = '          Cadd(x, y)say '   subtraction:   '        x        " - "         y         ' = '          Csub(x, y)say 'multiplication:   '        x        " * "         y         ' = '          Cmul(x, y)say '      division:   '        x        " ÷ "         y         ' = '          Cdiv(x, y)say '       inverse:   '        x        "                         = "          Cinv(x, y)say '  conjugate of:   '        x        "                         = "          Conj(x, y)say '   negation of:   '        x        "                         = "          Cneg(x, y)exit                                             /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/Conj: procedure; parse arg a ',' b,c ',' d;   call C#;    return C$( a , -b )Cadd: procedure; parse arg a ',' b,c ',' d; call C#; return C$(  a+c    ,   b+d  )Csub: procedure; parse arg a ',' b,c ',' d;   call C#;    return C$( a-c , b-d )Cmul: procedure; parse arg a ',' b,c ',' d; call C#; return C$( ac-bd   ,   bc+ad)Cdiv: procedure; parse arg a ',' b,c ',' d;   call C#;    return C$((ac+bd)/s, (bc-ad)/s)Cinv: return Cdiv(1, arg(1))Cneg: return Cmul(arg(1), -1)C_: return word(translate(arg(1), , '{[(JjIi)]}') 0, 1) /*get # or 0*/C#: a=C_(a); b=C_(b); c=C_(c); d=C_(d); ac=a*c; ad=a*d; bc=b*c; bd=b*d;s=c*c+d*d; returnC$:   parse arg r,c;    _='['r;   if c\=0  then _=_","c'j';   return _"]"   /*uses  j   */

output

      addition:    (5,3i)  +  ( .5,  6j)  =  [5.5,9j]
subtraction:    (5,3i)  -  ( .5,  6j)  =  [4.5,-3j]
multiplication:    (5,3i)  *  ( .5,  6j)  =  [-15.5,31.5j]
division:    (5,3i)  ÷  ( .5,  6j)  =  [0.565517241,-0.786206897j]
inverse:    (5,3i)                 =  [0.147058824,-0.0882352941j]
conjugate of:    (5,3i)                 =  [5,-3j]
negation of:    (5,3i)                 =  [-5,-3j]


## RLaB

 >> x = sqrt(-1)                        0 + 1i>> y = 10 + 5i                       10 + 5i>> z = 5*x-y                      -10 + 0i>> isreal(z)  1

## Ruby

 # Four ways to write complex numbers:a = Complex(1, 1)       # 1. call Kernel#Complexi = Complex::I          # 2. use Complex::Ib = 3.14159 + 1.25 * ic = '1/2+3/4i'.to_c     # 3. Use the .to_c method from String, result ((1/2)+(3/4)*i)c =  1.0/2+3/4i         # (0.5-(3/4)*i)  # Operations:puts a + b              # additionputs a * b              # multiplicationputs -a                 # negationputs 1.quo a            # multiplicative inverseputs a.conjugate        # complex conjugateputs a.conj             # alias for complex conjugate

Notes:

• All of these operations are safe with other numeric types. For example, 42.conjugate returns 42.
# Other ways to find the multiplicative inverse:puts 1.quo a            # always worksputs 1.0 / a            # works, but forces floating-point mathputs 1 / a              # might truncate to integer

## Rust

extern crate num;use num::complex::Complex; fn main() {    // two valid forms of definition    let a = Complex {re:-4.0, im: 5.0};    let b = Complex::new(1.0, 1.0);     println!("   a    = {}", a);    println!("   b    = {}", b);    println!(" a + b  = {}", a + b);    println!(" a * b  = {}", a * b);    println!(" 1 / a  = {}", a.inv());    println!("  -a    = {}", -a);    println!("conj(a) = {}", a.conj());}

## Scala

Works with: Scala version 2.8

Scala doesn't come with a Complex library, but one can be made:

package org.rosettacode package object ArithmeticComplex {  val i = Complex(0, 1)   implicit def fromDouble(d: Double) = Complex(d)  implicit def fromInt(i: Int) = Complex(i.toDouble)}   package ArithmeticComplex {  case class Complex(real: Double = 0.0, imag: Double = 0.0) {    def this(s: String) =       this("[\\d.]+(?!i)".r findFirstIn s getOrElse "0" toDouble,            "[\\d.]+(?=i)".r findFirstIn s getOrElse "0" toDouble)     def +(b: Complex) = Complex(real + b.real, imag + b.imag)    def -(b: Complex) = Complex(real - b.real, imag - b.imag)    def *(b: Complex) = Complex(real * b.real - imag * b.imag, real * b.imag + imag * b.real)    def inverse = {      val denom = real * real + imag * imag      Complex(real / denom, -imag / denom)    }    def /(b: Complex) = this * b.inverse    def unary_- = Complex(-real, -imag)    lazy val abs = math.hypot(real, imag)    override def toString = real + " + " + imag + "i"     def i = { require(imag == 0.0); Complex(imag = real) }  }   object Complex {    def apply(s: String) = new Complex(s)    def fromPolar(rho:Double, theta:Double) = Complex(rho*math.cos(theta), rho*math.sin(theta))  }}

Usage example:

scala> import org.rosettacode.ArithmeticComplex._import org.rosettacode.ArithmeticComplex._ scala> 1 + ires0: org.rosettacode.ArithmeticComplex.Complex = 1.0 + 1.0i scala> 1 + 2 * ires1: org.rosettacode.ArithmeticComplex.Complex = 1.0 + 2.0i scala> 2 + 1.ires2: org.rosettacode.ArithmeticComplex.Complex = 2.0 + 1.0i scala> res0 + res1res3: org.rosettacode.ArithmeticComplex.Complex = 2.0 + 3.0i scala> res1 * res2res4: org.rosettacode.ArithmeticComplex.Complex = 0.0 + 5.0i scala> res2 / res0res5: org.rosettacode.ArithmeticComplex.Complex = 1.5 + -0.5i scala> res1.inverseres6: org.rosettacode.ArithmeticComplex.Complex = 0.2 + -0.4i scala> -res6res7: org.rosettacode.ArithmeticComplex.Complex = -0.2 + 0.4i

## Scheme

Scheme implementations are not required to support complex numbers, but if they do, they are required to support complex number literals in one of the following standard formats[3]:

• rectangular coordinates: real+imagi (or real-imagi), where real is the real part and imag is the imaginary part. For a pure-imaginary number, the real part may be omitted but the sign of the imaginary part is mandatory (even if it is "+"): +imagi (or -imagi). If the imaginary part is 1 or -1, the imaginary part can be omitted, leaving only the +i or -i at the end.
• polar coordinates: r@theta, where r is the absolute value (magnitude) and theta is the angle
(define a 1+i)(define b 3.14159+1.25i) (define c (+ a b))(define c (* a b))(define c (/ 1 a))(define c (- a))

## zkl

var [const] GSL=Import("zklGSL");    // libGSL (GNU Scientific Library)(GSL.Z(3,4) + GSL.Z(1,2)).println(); // (4.00+6.00i)(GSL.Z(3,4) - GSL.Z(1,2)).println(); // (2.00+2.00i)(GSL.Z(3,4) * GSL.Z(1,2)).println(); // (-5.00+10.00i)(GSL.Z(3,4) / GSL.Z(1,2)).println(); // (2.20-0.40i)(GSL.Z(1,0) / GSL.Z(1,1)).println(); // (0.50-0.50i) // inversion(-GSL.Z(3,4)).println(); 	     // (-3.00-4.00i)GSL.Z(3,4).conjugate().println();    // (3.00-4.00i)
Output:
(4.00+6.00i)
(2.00+2.00i)
(-5.00+10.00i)
(2.20-0.40i)
(0.50-0.50i)
(-3.00-4.00i)
(3.00-4.00i)


## zonnon

 module Numbers;type	{public,immutable} 	Complex = record		re,im: real;	end Complex; operator {public} "+" (a,b: Complex): Complex;var	r: Complex;begin	r.re := a.re + b.re;	r.im := a.im + b.im;	return rend "+"; operator {public} "-" (a,b: Complex): Complex;var	r: Complex;begin	r.re := a.re - b.re;	r.im := a.im - b.im;	return rend "-"; operator {public} "*" (a,b: Complex): Complex;var	r: Complex;begin	r.re := a.re*b.re - a.im*b.im;	r.im := a.re*b.im + a.im*b.re;	return rend "*"; operator {public} "/" (a,b: Complex): Complex;var	r: Complex;	d: real;begin	d := b.re * b.re + b.im * b.im;	r.re := (a.re * b.re + a.im * b.im)/d;	r.im := (a.im * b.re - a.re * b.im)/d;	return rend "/"; operator {public} "-" (a: Complex): Complex;begin	a.im := -1 * a.im;	return aend "-"; operator {public} "~" (a: Complex): Complex;var	d: real;	c: Complex;begin	d := a.re * a.re + a.im * a.im;	c.re := a.re/d;	c.im := (-1.0 * a.im)/d;	return cend "~"; end Numbers.  module Main;import Numbers; var	a,b,c: Numbers.Complex; 	procedure Writeln(c: Numbers.Complex);	begin		writeln("(",c.re:4:2,";",c.im:4:2,"i)");	end Writeln; 	procedure NewComplex(x,y: real): Numbers.Complex;	var		r: Numbers.Complex;	begin		r.re := x;r.im := y;		return r	end NewComplex; begin	a := NewComplex(1.5,3.0);	b := NewComplex(1.0,1.0);	Writeln(a + b);	Writeln(a - b);	Writeln(a * b);	Writeln(a / b);	Writeln(-a);	Writeln(~b);end Main. 
Output:
   ( 2,5   ;   4  i)
(  ,5   ;   2  i)
(-1,5   ; 4,5  i)
(2,25   ; ,75  i)
( 1,5   ;  -3  i)
(  ,5   ; -,5  i)


## ZX Spectrum Basic

Translation of: BBC BASIC
5 LET complex=2: LET r=1: LET i=210 DIM a(complex): LET a(r)=1.0: LET a(i)=1.020 DIM b(complex): LET b(r)=PI: LET b(i)=1.230 DIM o(complex)40 REM add50 LET o(r)=a(r)+b(r)60 LET o(i)=a(i)+b(i)70 PRINT "Result of addition is:": GO SUB 100080 REM mult90 LET o(r)=a(r)*b(r)-a(i)*b(i)100 LET o(i)=a(i)*b(r)+a(r)*b(i)110 PRINT "Result of multiplication is:": GO SUB 1000120 REM neg130 LET o(r)=-a(r)140 LET o(i)=-a(i)150 PRINT "Result of negation is:": GO SUB 1000160 LET denom=a(r)^2+a(i)^2170 LET o(r)=a(r)/denom180 LET o(i)=-a(i)/denom190 PRINT "Result of inversion is:": GO SUB 1000200 STOP 1000 IF o(i)>=0 THEN PRINT o(r);" + ";o(i);"i": RETURN 1010 PRINT o(r);" - ";-o(i);"i": RETURN  
Output:
Result of addition is:
4.1415927 + 2.2i
Result of multiplication is:
1.9415927 + 4.3415927i
Result of negation is:
-1 - 1i
Result of inversion is:
0.5 - 0.5i`