Arithmetic/Complex
From Rosetta Code
(Redirected from Complex numbers)
You are encouraged to solve this task according to the task description, using any language you may know.
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.
[edit] 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;
[edit] 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:(Output:
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
)
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
[edit] AutoHotkey
contributed by Laszlo on the ahk forum
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")
}
[edit] BASIC
Works with: QuickBasic version 4.5
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
Output:
3 + 3 i 0 + 4 i .5 +-.5 i -1 +-1 i
[edit] 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>
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");
}
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;
}
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");
}
[edit] 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;
}
[edit] C#
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);
}
}
[edit] 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)
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
[edit] D
Complex number is a D built-in type.
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
[edit] 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;}
[edit] Factor
C{ 1 2 } C{ 0.9 -2.78 } {
[ + . ]
[ - . ]
[ * . ]
[ / . ]
[ ^ . ]
[ drop sin . ]
[ drop log . ]
[ drop sqrt . ]
} 2cleave
[edit] Forth
Library: Forth Scientific Library 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.
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.
[edit] 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 / a
end 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
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
[edit] Go
package main
import "fmt"
func main() {
a := 1+1i
b := 3.14159+1.25i
fmt.Println(a + b)
fmt.Println(a * b)
fmt.Println(1 / a)
fmt.Println(-a)
}
[edit] 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 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
}
}
Javadoc on the polar-related methods uses the following Greek alphabet encoded entities: ρ: ρ (rho), θ: θ (theta), and π: π (pi).
Test Program (patterned after the Fortran example):
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()
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.
[edit] 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)
Output:
*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)
[edit] 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)
[edit] Icon and Unicon
[edit] Icon
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.
Library: Icon Programming Library provides complex number support supplemented by the code below.
link complex # for complex number support
procedure SetupComplex() #: used to setup safe complex
COMPLEX() # replace complex record constructor
SetupComplex := 1 # never call here again
return
end
procedure COMPLEX(rpart,ipart) #: new safe record constructor and coercion
initial complex :=: COMPLEX # get in front of record constructor
return if /ipart & (type(rpart) == "complex")
then rpart # already complex
else COMPLEX( real(\rpart | 0.0), real(\ipart|0) ) # create a new complex number
end
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.
Sample 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)
[edit] Unicon
This Icon solution works in Unicon.
This could be better implemented as an object. Unicon doesn't allow for operator overloading at the current time.
[edit] 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
4.14159j2.2
x*y
1.94159j4.34159
%x
0.5j_0.5
-x
_1j_1
[edit] 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));
}
}
[edit] 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) )
}
[edit] 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)
[edit] 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
Other than that, the task merely asks for
x+y;
x*y;
-x;
1/x;
[edit] 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:
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
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 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
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.
[edit] 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
[edit] 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)
[edit] Octave
GNU Octave handles naturally complex numbers:
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
%...
[edit] 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.
[edit] Perl
The Math::Complex module implements complex arithmetic.
my $a = 1 + 1*i;
my $b = 3.14159 + 1.25*i;
print "$_\n" foreach $a + $b, $a * $b, 1 / $a, -$a;
[edit] Perl 6
Works with: Rakudo version #22 "Thousand Oaks"
my $a = 1 + 1i;
my $b = pi + 1.25i;
.say for $a + $b, $a * $b, 1 / $a, -$a;
[edit] 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. */
[edit] 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
[edit] 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 values
1 +: 1 -> a;
2 +: 5 -> b;
a+b =>
a*b =>
1/a =>
a-b =>
a-a =>
a/b =>
a/a =>
[edit] Python
>>> z1 = 1.5 + 3j
>>> z2 = 1.5 + 1.5j
>>> z1 + z2
(3+4.5j)
>>> z1 - z2
1.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.real
1.5
>>> z1.imag
3.0
>>>
[edit] R
Translation of: Octave
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
[edit] 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
[edit] 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)
override def toString = real + " + " + imag + "i"
def i = { require(imag == 0.0); Complex(imag = real) }
}
object Complex {
def apply(s: String) = new Complex(s)
}
}
Usage example:
scala> import org.rosettacode.ArithmeticComplex._
import org.rosettacode.ArithmeticComplex._
scala> 1 + i
res0: org.rosettacode.ArithmeticComplex.Complex = 1.0 + 1.0i
scala> 1 + 2 * i
res1: org.rosettacode.ArithmeticComplex.Complex = 1.0 + 2.0i
scala> 2 + 1.i
res2: org.rosettacode.ArithmeticComplex.Complex = 2.0 + 1.0i
scala> res0 + res1
res3: org.rosettacode.ArithmeticComplex.Complex = 2.0 + 3.0i
scala> res1 * res2
res4: org.rosettacode.ArithmeticComplex.Complex = 0.0 + 5.0i
scala> res2 / res0
res5: org.rosettacode.ArithmeticComplex.Complex = 1.5 + -0.5i
scala> res1.inverse
res6: org.rosettacode.ArithmeticComplex.Complex = 0.2 + -0.4i
scala> -res6
res7: org.rosettacode.ArithmeticComplex.Complex = -0.2 + 0.4i
[edit] 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(orreal-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+ior-iat 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))
[edit] Seed7
$ include "seed7_05.s7i";
include "float.s7i";
include "complex.s7i";
const proc: main is func
local
var complex: a is complex(1.0, 1.0);
var complex: b is complex(3.14159, 1.2);
begin
writeln("a=" <& a digits 5);
writeln("b=" <& b digits 5);
# addition
writeln("a+b=" <& a + b digits 5);
# multiplication
writeln("a*b=" <& a * b digits 5);
# inversion
writeln("1/a=" <& complex(1.0) / a digits 5);
# negation
writeln("-a=" <& -a digits 5);
end func;
[edit] 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.
].
[edit] Smalltalk
Works with: GNU 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.
[edit] SNOBOL4
Works with: Macro Spitbol Works with: Snobol4+ Works with: CSnobol
* # Define complex datatype
data('complex(r,i)')
* # Addition
define('addx(x1,x2)a,b,c,d') :(addx_end)
addx a = r(x1); b = i(x1); c = r(x2); d = i(x2)
addx = complex(a + c, b + d) :(return)
addx_end
* # Multiplication
define('multx(x1,x2)a,b,c,d') :(multx_end)
multx a = r(x1); b = i(x1); c = r(x2); d = i(x2)
multx = complex(a * c - b * d, b * c + a * d) :(return)
multx_end
* # Negation
define('negx(x)') :(negx_end)
negx negx = complex(-r(x), -i(x)) :(return)
negx_end
* # Inverse
define('invx(x)d') :(invx_end)
invx d = (r(x) * r(x)) + (i(x) * i(x))
invx = complex(1.0 * r(x) / d, 1.0 * -i(x) / d) :(return)
invx_end
* # Print compex number: a+bi / a-bi
define('printx(x)sign') :(printx_end)
printx sign = ge(i(x),0) '+'
printx = r(x) sign i(x) 'i' :(return)
printx_end
* # Test and display
a = complex(1,1)
b = complex(3.14159, 1.2)
output = printx( addx(a,b) )
output = printx( multx(a,b) )
output = printx( negx(a) ) ', ' printx( negx(b) )
output = printx( invx(a) ) ', ' printx( invx(b) )
end
Output:
4.14159+2.2i 1.94159+4.34159i -1-1i, -3.14159-1.2i 0.5-0.5i, 0.277781125-0.106104663i
[edit] Tcl
Using the math::complexnumbers package from Library: tcllib
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
[edit] 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 Translation of: Common Lisp.
■ √(–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
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).
■ (1∠π/4)
√(2)/2 + √(2)/2*
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.
[edit] 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.
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)>
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>
Categories: Programming Tasks | Arithmetic operations | Ada | ALGOL 68 | AutoHotkey | BASIC | C | C++ | C sharp | Common Lisp | D | F Sharp | Factor | Forth | Forth Scientific Library | Fortran | Go | Groovy | Haskell | IDL | Icon | Icon Programming Library | Unicon | J | Java | JavaScript | Tasks needing attention | Lua | Maple | Mathematica | MATLAB | OCaml | Octave | Pascal | Perl | Perl 6 | PL/I | PicoLisp | Pop11 | Python | R | Ruby | Scala | Scheme | Seed7 | Slate | Smalltalk | SNOBOL4 | Tcl | Tcllib | TI-89 BASIC | Ursala | M4/Omit
