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 "a + b*i" (sometimes shown as "b + a*i") where a and b are real numbers and i is the square root of -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 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.
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.
Ada
<lang ada>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
C := Conjugate (C);
end Complex_Operations;</lang>
ALGOL 68
<lang algol68>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
)</lang> Output: <lang algol68>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</lang>
AutoHotkey
contributed by Laszlo on the ahk forum <lang AutoHotkey>Cset(C,1,1) MsgBox % Cstr(C) ; 1 + i*1 Cneg(C,C) MsgBox % Cstr(C) ; -1 - i*1 Cadd(C,C,C) MsgBox % Cstr(C) ; -2 - i*2 Cinv(D,C) MsgBox % Cstr(D) ; -0.25 + 0.25*i Cmul(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")
}</lang>
BASIC
<lang qbasic>TYPE complex
real AS DOUBLE
imag AS DOUBLE
END TYPE DECLARE SUB add (a AS complex, b AS complex, c AS complex) DECLARE SUB mult (a AS complex, b AS complex, c AS complex) DECLARE SUB inv (a AS complex, b AS complex) DECLARE SUB neg (a AS complex, b AS complex) CLS DIM x AS complex DIM y AS complex DIM z AS complex x.real = 1 x.imag = 1 y.real = 2 y.imag = 2 CALL add(x, y, z) PRINT z.real; "+"; z.imag; "i" CALL mult(x, y, z) PRINT z.real; "+"; z.imag; "i" CALL inv(x, z) PRINT z.real; "+"; z.imag; "i" CALL neg(x, z) PRINT z.real; "+"; z.imag; "i"
SUB add (a AS complex, b AS complex, c AS complex)
c.real = a.real + b.real
c.imag = a.imag + b.imag
END 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 / denom
END 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.real
END SUB
SUB neg (a AS complex, b AS complex)
b.real = -a.real
b.imag = -a.imag
END SUB</lang> Output:
3 + 3 i 0 + 4 i .5 +-.5 i -1 +-1 i
C
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] <lang c>#include <complex.h>
void cprint(double complex c) {
printf("%lf%+lfI", 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); printf("\n");
}</lang>
User-defined type: <lang c>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;
}
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;
}
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("\n");
}</lang>
C++
<lang cpp>#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;
}</lang>
C#
<lang csharp>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);
}
}</lang>
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:
<lang lisp>> (sqrt -1)
- C(0.0 1.0)
> (expt #c(0 1) 2) -1</lang>
Here are some arithmetic operations on complex numbers:
<lang lisp>> (+ #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)</lang>
Complex numbers can be constructed from real and imaginary parts using the complex function, and taken apart using the realpart and imagpart functions.
<lang lisp>> (complex 64 (/ 3 4))
- C(64 3/4)
> (realpart #c(5 5)) 5
> (imagpart (complex 0 pi)) 3.141592653589793d0</lang>
D
Complex number is a D built-in type. <lang d>auto x = 1F+1i ; // auto type to cfloat auto y = 3.14159+1.2i ; // cdouble creal z ;
// addition z = x + y ; writefln(z) ; // => 4.14159+2.2i // multiplication z = x * y ; writefln(z) ; // => 1.94159+4.34159i // inversion z = 1.0 / x ; writefln(z) ; // => 0.5+-0.5i // negation z = -x ; writefln(z) ; // => -1+-1i</lang>
F#
Entered into an interactive session to show the results: <lang fsharp> > 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;}
</lang>
Factor
<lang factor>C{ 1 2 } C{ 0.9 -2.78 } {
[ + . ] [ - . ] [ * . ] [ / . ] [ ^ . ] [ drop sin . ] [ drop log . ] [ drop sqrt . ]
} 2cleave</lang>
Forth
There is no standard syntax or mechanism for complex numbers. The FSL provides several implementations suitable for different uses. This example uses the existing floating point stack, but other libraries define a separate complex stack and/or a fixed-point implementation suitable for microcontrollers and DSPs.
<lang forth>include complex.seq
- ZNEGATE ( r i -- -r -i ) fswap fnegate fswap fnegate ;
zvariable x zvariable y 1e 1e x z! pi 1.2e y z!
x z@ y z@ z+ z. x z@ y z@ z* z. 1+0i x z@ z/ z. x z@ znegate z.</lang>
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: <lang fortran>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 / a
end program cdemo</lang>
And, although you did not ask, here are demonstrations of some other common complex number operations <lang fortran>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
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</lang>
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: <lang groovy>class Complex {
final Number real, imag
static final Complex I = [0,1] as Complex
Complex(Number real) { this(real, 0) }
Complex(real, imag) { this.real = real; this.imag = imag }
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 abs () { Math.sqrt( real*real + imag*imag ) }
/** the complex reciprocal of this complex number. */
Complex recip() { (~this) / ((this * (~this)).real) }
/** derived angle θ (theta) for polar form.
* Normalized to 0 ≤ θ < 2π. */
Number getTheta() {
def theta = Math.atan2(imag,real)
theta = theta < 0 ? theta + 2 * Math.PI : theta
}
/** derived magnitude ρ (rho) for polar form. */
Number getRho() { this.abs() }
/** Runs Euler's polar-to-Cartesian complex conversion,
* converting [ρ, θ] inputs into a [real, imag]-based complex number */
static Complex fromPolar(Number rho, Number theta) {
[rho * Math.cos(theta), rho * Math.sin(theta)] as Complex
}
/** Creates new complex with same magnitude ρ, but different angle θ */
Complex withTheta(Number theta) { fromPolar(this.rho, theta) }
/** Creates new complex with same angle θ, but different magnitude ρ */
Complex withRho(Number rho) { fromPolar(rho, this.theta) }
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(other) {
other != null && (other instanceof Complex \
? [real, imag] == [other.real, other.imag] \
: other instanceof Number && [real, imag] == [other, 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
}
}</lang> Javadoc on the polar-related methods uses the following Greek alphabet encoded entities: ρ: ρ (rho), θ: θ (theta), and π: π (pi).
Test Program (patterned after the Fortran example): <lang groovy>def tol = 0.000000001 // tolerance: acceptable "wrongness" to account for rounding error
println 'Demo 1: functionality as requested' def a = [5,3] as Complex println 'a == ' + a def b = [0.5,6] as Complex println 'b == ' + b
println "a + b == (${a}) + (${b}) == " + (a + b) println "a * b == (${a}) * (${b}) == " + (a * b) assert a + (-a) == 0 println "-a == -(${a}) == " + (-a) assert (a * a.recip() - 1).abs() < tol println "1/a == (${a}).recip() == " + (a.recip()) println()
println 'Demo 2: other functionality not requested, but important for completeness' println "a - b == (${a}) - (${b}) == " + (a - b) println "a / b == (${a}) / (${b}) == " + (a / b) println "a ** b == (${a}) ** (${b}) == " + (a ** b) println 'a.real == ' + a.real println 'a.imag == ' + a.imag println 'a.rho == ' + a.rho println 'a.theta == ' + a.theta println '|a| == ' + a.abs() println 'a_bar == ' + ~a
def rho = 10 def piOverTheta = 3 def theta = Math.PI / piOverTheta def fromPolar1 = Complex.fromPolar(rho, theta) // direct polar-to-cartesian conversion def fromPolar2 = Complex.exp(Complex.I * theta) * rho // Euler's equation println "rho*cos(theta) + rho*i*sin(theta) == ${rho}*cos(pi/${piOverTheta}) + ${rho}*i*sin(pi/${piOverTheta}) == " + fromPolar1 println "rho * exp(i * theta) == ${rho} * exp(i * pi/${piOverTheta}) == " + fromPolar2 assert (fromPolar1 - fromPolar2).abs() < tol println()</lang>
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 Demo 2: other functionality not requested, but important for completeness a - b == (5 + 3i) - (0.5 + 6i) == 4.5 - 3i a / b == (5 + 3i) / (0.5 + 6i) == 0.56551724145 - 0.78620689665i a ** b == (5 + 3i) ** (0.5 + 6i) == -0.013750112198456855 - 0.09332524760169053i a.real == 5 a.imag == 3 a.rho == 5.830951894845301 a.theta == 0.5404195002705842 |a| == 5.830951894845301 a_bar == 5 - 3i rho*cos(theta) + rho*i*sin(theta) == 10*cos(pi/3) + 10*i*sin(pi/3) == 5.000000000000001 + 8.660254037844386i rho * exp(i * theta) == 10 * exp(i * pi/3) == 5.000000000000001 + 8.660254037844386i
A Groovy equivalent to the "unit circle" part of the Fortran demo is shown in the Roots of unity task.
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.
<lang haskell>import Data.Complex
main = do
let a = 1.0 :+ 2.0 -- complex number 1+2i let b = fromInteger 4 -- complex number 4+0i 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)</lang>
Output:
<lang haskell>*Main> main Add: 5.0 :+ 2.0 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)</lang>
IDL
complex (and dcomplex for double-precision) is a built-in data type in IDL:
<lang 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)</lang>
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. <lang j> x=: 1j1
y=: 3.14159j1.2 x+y
4.14159j2.2
x*y
1.94159j4.34159
%x
0.5j_0.5
-x
_1j_1</lang>
Java
<lang java>public class Complex{
public final double real; public final double imag;
public Complex(){this(0,0)}//default values to 0...force of habit
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 String toString(){ //override Object's 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));
}
}</lang>
JavaScript
<lang 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 ); }
// BONUSES!
Complex.prototype.toString = function(){
return (this.r !== 0 ? this.r : "") + (this.r !== 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) ) }</lang>
Lua
<lang lua> --defines addition, subtraction, negation, multiplication, division, conjugation, norms, and a conversion to strings. 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, __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,
string = function(u) return u.real .. " + " .. u.imag .. "i" end
}
return operations[index] and operations[index](u)
end, __newindex = function() error() end }, { __call = function(realpart, imagpart) return setmetatable({real = realpart, imag = imagpart}, complex) end } )
local i, j = complex(2, 3), complex(1, 1)
print(i.string .. " + " .. j.string .. " = " .. (i+j).string) print(i.string .. " - " .. j.string .. " = " .. (i-j).string) print(i.string .. " * " .. j.string .. " = " .. (i*j).string) print(i.string .. " / " .. j.string .. " = " .. (i/j).string) print("|" .. i.string .. "| = " .. math.sqrt(i.norm)) print(i.string .. "* = " .. i.conj.string) </lang>
Maple
Maple has I (the square root of -1) built-in. Thus:
<lang maple>x := 1+I; y := Pi+I*1.2;</lang>
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:
<lang maple>x*y;
==> (1 + I) (Pi + 1.2 I)
simplify(x*y);
==> 1.941592654 + 4.341592654 I</lang>
Other than that, the task merely asks for
<lang maple>x+y; x*y; -x; 1/x;</lang>
Mathematica
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: <lang Mathematica>x=1+2I y=3+4I
x+y => 4 + 6 I x-y => -2 - 2 I y x => -5 + 10 I y/x => 11/5 - (2 I)/5 x^3 => -11 - 2 I y^4 => -527 - 336 I x^y => (1 + 2 I)^(3 + 4 I) N[x^y] => 0.12901 + 0.0339241 I</lang> 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!): <lang Mathematica>Exp Log Sin Cos Tan Csc Sec Cot ArcSin ArcCos ArcTan ArcCsc ArcSec ArcCot Sinh Cosh Tanh Csch Sech Coth ArcSinh ArcCosh ArcTanh ArcCsch ArcSech ArcCoth Sinc Haversine InverseHaversine Factorial Gamma PolyGamma LogGamma Erf BarnesG Hyperfactorial Zeta ProductLog RamanujanTauL</lang> 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.
OCaml
The Complex module from the standard library provides the functionality of complex numbers: <lang ocaml>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)</lang>
Octave
GNU Octave handles naturally complex numbers: <lang octave>z1 = 1.5 + 3i; z2 = 1.5 + 1.5i; disp(z1 + z2); % 3.0 + 4.5i disp(z1 - z2); % 0.0 + 1.5i disp(z1 * z2); % -2.25 + 6.75i disp(z1 / z2); % 1.5 + 0.5i disp(-z1); % -1.5 - 3i disp(z1'); % 1.5 - 3i disp(abs(z1)); % 3.3541 = sqrt(z1*z1') disp(z1 ^ z2); % -1.10248 - 0.38306i disp( exp(z1) ); % -4.43684 + 0.63246i disp( imag(z1) ); % 3 disp( real(z2) ); % 1.5 %...</lang>
Pascal
<lang pascal>program showcomplex(output);
type
complex = record
re,im: real
end;
var
z1, z2, zr: complex;
procedure set(var result: complex; re, im: real);
begin result.re := re; result.im := im end;
procedure print(a: complex);
begin
write('(', a.re , ',', a.im, ')')
end;
procedure add(var result: complex; a, b: complex);
begin result.re := a.re + b.re; result.im := a.im + b.im; end;
procedure neg(var result: complex; a: complex);
begin result.re := -a.re; result.im := -a.im end;
procedure mult(var result: complex; a, b: complex);
begin result.re := a.re*b.re - a.im*b.im; result.im := a.re*b.im + a.im*b.re end;
procedure inv(var result: complex; a: complex);
var anorm: real; begin anorm := a.re*a.re + a.im*a.im; result.re := a.re/anorm; result.im := -a.im/anorm end;
begin
set(z1, 3, 4); set(z2, 5, 6);
neg(zr, z1);
print(zr); { prints (-3,-4) }
writeln;
add(zr, z1, z2);
print(zr); { prints (8,10) }
writeln;
inv(zr, z1);
print(zr); { prints (0.12,-0.16) }
writeln;
mul(zr, z1, z2);
print(zr); { prints (-9,38) }
writeln
end.</lang>
Perl
The Math::Complex module implements complex arithmetic.
<lang perl>my $a = 1 + 1*i;
my $b = 3.14159 + 1.25*i;
print "$_\n" foreach $a + $b, $a * $b, 1 / $a, -$a;</lang>
Perl 6
<lang perl6>my $a = 1 + 1i; my $b = pi + 1.25i;
.say for $a + $b, $a * $b, 1 / $a, -$a;</lang>
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.
<lang pop11>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 values
1 +: 1 -> a; 2 +: 5 -> b; a+b => a*b => 1/a => a-b => a-a => a/b => a/a =></lang>
Python
<lang python>a = 1 + 1j b = 3.14159 + 1.25j
c = a + b c = a * b c = 1 / a c = -a</lang>
R
<lang R>z1 <- 1.5 + 3i z2 <- 1.5 + 1.5i print(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</lang>
Ruby
<lang ruby>require 'complex'
a = Complex(1, 1) a = 1 + 1.im # alternative method b = 3.14159 + 1.25.im
c = a + b c = a * b c = 1.0 / a c = -a</lang>
Scheme
<lang scheme>(define a (make-rectangular 1 1)) (define b (make-rectangular 3.14159 1.25))
(define c (+ a b)) (define c (* a b)) (define c (/ 1 a)) (define c (- a))</lang>
Slate
<lang slate>[| a b |
a: 1 + 1 i. b: Pi + 1.2 i. print: a + b. print: a * b. print: a / b. print: a reciprocal. print: a conjugated. print: a abs. print: a negated.
].</lang>
Smalltalk
<lang smalltalk>PackageLoader fileInPackage: 'Complex'. |a b| a := 1 + 1 i. b := 3.14159 + 1.2 i. (a + b) displayNl. (a * b) displayNl. (a / b) displayNl. a reciprocal displayNl. a conjugate displayNl. a abs displayNl. a real displayNl. a imaginary displayNl. a negated displayNl.</lang>
Tcl
Using the math::complexnumbers package from
<lang tcl>package require math::complexnumbers namespace import math::complexnumbers::*
set a [complex 1 1] set b [complex 3.14159 1.2] puts [tostring [+ $a $b]] ;# ==> 4.14159+2.2i puts [tostring [* $a $b]] ;# ==> 1.94159+4.34159i puts [tostring [pow $a [complex -1 0]]] ;# ==> 0.5-0.4999999999999999i puts [tostring [- $a]] ;# ==> -1.0-i</lang>
TI-89 BASIC
TI-89 BASIC has built-in complex number support; the normal arithmetic operators + - * / are used.
- Character set note: the symbol for the imaginary unit is not the normal "i" but a different character (Unicode: U+F02F "" (private use area); this character should display with the "TI Uni" font). Also, U+3013 EN DASH “–”, displayed on the TI as a superscript minus, is used for the minus sign on numbers, distinct from ASCII "-" used for subtraction.
The choice of examples here is
.
<lang ti89b>■ √(–1) ■ ^2 —1 ■ + 1 1 + ■ (1+) * 2 2 + 2* ■ (1+) (2) —2 + 2* ■ —(1+) —1 - ■ 1/(2) —1 - ■ real(1 + 2) 1 ■ imag(1 + 2) 2</lang>
Complex numbers can also be entered and displayed in polar form. (This example shows input in polar form while the complex display mode is rectangular and the angle mode is radians).
<lang ti89b>■ (1∠π/4)
√(2)/2 + √(2)/2*</lang>
Note that the parentheses around ∠ notation are required. It has a related use in vectors: (1∠π/4) is a complex number, [1,∠π/4] is a vector in two dimensions in polar notation, and [(1∠π/4)] is a complex number in a vector.
Ursala
Complex numbers are a primitive type that can be parsed in fixed or exponential formats, with either i or j notation as shown. The usual complex arithmetic and transcendental functions are callable using the syntax libname..funcname or a recognizable truncation (e.g., c..add or ..csin). Real operands are promoted to complex.
<lang Ursala>u = 3.785e+00-1.969e+00i v = 9.545e-01-3.305e+00j
- cast %jL
examples =
<
complex..add (u,v), complex..mul (u,v), complex..sub (0.,u), complex..div (1.,v)></lang>
output:
< 4.740e+00-5.274e+00j, -2.895e+00-1.439e+01j, 3.785e+00-1.969e+00j, 8.066e-02+2.793e-01j>