Arithmetic/Complex: Difference between revisions
→{{header|PascalABC.NET}}
Walterpachl (talk | contribs) (→{{header|ooRexx}}: corrected the 'inv' method and updated output shown) |
|||
(123 intermediate revisions by 64 users not shown) | |||
Line 1:
{{task|Arithmetic operations}}
A '''[[wp:Complex number|complex number]]''' is a number which can be written as:
<big><math>a + b \times i</math></big>
(sometimes shown as:
<big><math>b + a \times i</math></big>
where <big><math>a</math></big> and <big><math>b</math></big> are real numbers, and [[wp:Imaginary_unit|<big><math>i</math></big>]] is <big>√{{overline| -1 }}</big>
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 <big><math>i</math></big>.
;Task:
* 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.
<br>
By definition, the [[wp:complex conjugate|complex conjugate]] of
<big><math>a + bi</math></big>
is
<big><math>a - bi</math></big>
<br>
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.
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">V z1 = 1.5 + 3i
V z2 = 1.5 + 1.5i
print(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)</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="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)
FI
RETURN (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.i
RETURN
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.i
RETURN
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.r
RETURN
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.r
RETURN
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.i
RETURN
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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Complex.png Screenshot from Atari 8-bit computer]
<pre>
(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
</pre>
=={{header|Ada}}==
<
with Ada.Text_IO.Complex_IO;
Line 52 ⟶ 250:
New_Line;
-- Conjugation
C := Conjugate (C); Put(C);
end Complex_Operations;</syntaxhighlight>
=={{header|ALGOL 68}}==
Line 60 ⟶ 259:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}
<
FORMAT compl fmt = $g(-7,5)"⊥"g(-7,5)$;
Line 86 ⟶ 285:
);
compl operations
)</
{{out}}<pre>
a=1.00000⊥1.00000
b=3.14159⊥1.20000
Line 95 ⟶ 295:
-a=-1.0000⊥-1.0000
</pre>
=={{header|ALGOL W}}==
Complex is a built-in type in Algol W.
<syntaxhighlight lang="algolw">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.</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|APL}}==
<syntaxhighlight lang="text">
x←1j1 ⍝assignment
y←5.25j1.5
Line 107 ⟶ 346:
-x ⍝negation
¯1J¯1
</syntaxhighlight>
=={{header|App Inventor}}==
Line 113 ⟶ 352:
The linked image gives a few examples of complex arithmetic and a custom complex conjugate function.<br>
[https://lh4.googleusercontent.com/-4M57lWIh_r8/Uuqgoec-hrI/AAAAAAAAJ74/2oj_5eelUR4/w1197-h766-no/Capture.PNG View the blocks and app screen...]
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">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]</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|AutoHotkey}}==
contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276431.html#276431 forum]
<
MsgBox % Cstr(C) ; 1 + i*1
Cneg(C,C)
Line 162 ⟶ 425:
NumPut( Cre(A)/d,C,0,"double")
NumPut(-Cim(A)/d,C,8,"double")
}</syntaxhighlight>
=={{header|AWK}}==
contributed by af
<syntaxhighlight lang="awk"># simulate a struct using associative arrays
function 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)
}</syntaxhighlight>
=={{header|BASIC}}==
{{works with|QuickBasic|4.5}}
<
real AS DOUBLE
imag AS DOUBLE
END 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
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)
CLS
DIM x AS complex
Line 182 ⟶ 509:
y.real = 2
y.imag = 2
PRINT
PRINT " e y = "; y.real; "+"; y.imag; "i"
PRINT
CALL 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
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.imag
Line 211 ⟶ 548:
b.real = -a.real
b.imag = -a.imag
END SUB
SUB conj (a AS complex, b AS complex)
b.real = a.real
b.imag = -a.imag
END 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.imag
END SUB
</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
DIM a{} = Complex{} : a.r = 1.0 : a.i = 1.0
Line 259 ⟶ 618:
DEF FNcomplexshow(src{})
IF src.i >= 0 THEN = STR$(src.r) + " + " +STR$(src.i) + "i"
= STR$(src.r) + " - " + STR$(-src.i) + "i"</
{{out}}
<pre>Result of addition is 4.14159265 + 2.2i
Result of multiplication is 1.94159265 + 4.34159265i
Line 268 ⟶ 627:
=={{header|Bracmat}}==
Bracmat recognizes the symbol <code>i</code> as the square root of <code>-1</code>. The results of the functions below are not necessarily of the form <code>a+b*i</code>, 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 <code>multiply</code> and <code>negate</code> there are terms <code>1</code> and <code>-1</code>. 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.
<
& ( multiply
= a b.!arg:(?a,?b)&1+!a*!b+-1
Line 295 ⟶ 654:
& out
$ ("sin$x minus conjugate sin$x =" sin$x+negate$(conjugate$(sin$x)))
& done;</
{{out}}
<pre>(a+i*b)+(a+i*b) = 2*a+2*i*b
(a+i*b)+(a+-i*b) = 2*a
Line 310 ⟶ 669:
{{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++]].) [http://www.opengroup.org/onlinepubs/009695399/basedefs/complex.h.html] [http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.vacpp7a.doc/language/ref/clrc03complex_types.htm]
<
#include <stdio.h>
Line 341 ⟶ 700:
c = conj(a);
printf("\nconj a="); cprint(c); printf("\n");
}</
{{works with|C89}}
User-defined type:
<
double real;
double imag;
Line 405 ⟶ 764:
printf("\n-a="); put(neg(a));
printf("\nconj a="); put(conj(a)); printf("\n");
}</
=={{header|C sharp|C#}}==
{{works with|C sharp|C#|4.0}}
<
{
using System;
Line 425 ⟶ 784:
}
}
}</
{{works with|C sharp|C#|1.2}}
<
public struct ComplexNumber
Line 631 ⟶ 990:
Console.WriteLine(ComplexMath.Power(j, 0) == 1.0);
}
}</
=={{header|C++}}==
<
#include <complex>
using std::complex;
Line 652 ⟶ 1,011:
// conjugate
std::cout << std::conj(a) << std::endl;
}</
=={{header|Clojure}}==
Line 658 ⟶ 1,017:
Therefore, we use defrecord and the multimethods in
clojure.algo.generic.arithmetic to make a Complex number type.
<
(:require [clojure.algo.generic.arithmetic :as ga])
(:import [java.lang Number]))
Line 678 ⟶ 1,037:
(defmethod ga/- Complex
[x] (->> x vals (map -) (apply ->Complex)))
(defmethod ga/* [Complex Complex]
Line 695 ⟶ 1,054:
(let [m (+ (* r r) (* i i))]
(->Complex (/ r m) (- (/ i m)))))
</syntaxhighlight>
=={{header|COBOL}}==
Line 702 ⟶ 1,061:
===.NET Complex class===
{{trans|C#}}
<
$SET ILUSING "System"
$SET ILUSING "System.Numerics"
Line 715 ⟶ 1,074:
end-perform
end method.
end class.</
===Implementation===
<
class-id Prog.
method-id. Main static.
Line 815 ⟶ 1,174:
end operator.
end class.</
=={{header|CoffeeScript}}==
<
# create an immutable Complex type
class Complex
Line 879 ⟶ 1,238:
quotient = product.times inverse
console.log "(#{product}) / (#{b}) = #{quotient}"
</syntaxhighlight>
{{out}}
<
> coffee complex.coffee
(5 + 3i) + (4 - 3i) = 9
Line 890 ⟶ 1,249:
1 / (4 - 3i) = 0.16 + 0.12i
(29 - 3i) / (4 - 3i) = 5 + 3i
</
=={{header|Common Lisp}}==
Line 896 ⟶ 1,255:
Complex numbers are a built-in numeric type in Common Lisp. The literal syntax for a complex number is <tt>#C(<var>real</var> <var>imaginary</var>)</tt>. The components of a complex number may be integers, ratios, or floating-point. Arithmetic operations automatically return complex (or real) numbers when appropriate:
<
#C(0.0 1.0)
> (expt #c(0 1) 2)
-1</
Here are some arithmetic operations on complex numbers:
<
#C(1 1)
Line 920 ⟶ 1,279:
> (conjugate #c(1 1))
#C(1 -1)</
Complex numbers can be constructed from real and imaginary parts using the <tt>complex</tt> function, and taken apart using the <tt>realpart</tt> and <tt>imagpart</tt> functions.
<
#C(64 3/4)
Line 931 ⟶ 1,290:
> (imagpart (complex 0 pi))
3.141592653589793d0</
=={{header|Component Pascal}}==
BlackBox Component Builder
<
MODULE Complex;
IMPORT StdLog;
Line 1,022 ⟶ 1,381:
END Complex.
</syntaxhighlight>
Execute: ^Q Complex.Do<br/>
{{out}}
<pre>
x: Complex( 1.5, 3.0i );
Line 1,035 ⟶ 1,394:
x': Complex( 1.5, -3.0i );
</pre>
=={{header|D}}==
Built-in complex numbers are now deprecated in D, to simplify the language.
<
void main() {
Line 1,047 ⟶ 1,407:
writeln(1.0 / x); // inversion
writeln(-x); // negation
}</
{{out}}
<pre>4.14159+2.2i
1.94159+4.34159i
Line 1,055 ⟶ 1,415:
=={{header|Dart}}==
<
class complex {
Line 1,107 ⟶ 1,467:
}
</syntaxhighlight>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.VarCmplx}}
<syntaxhighlight lang="delphi">
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.</syntaxhighlight>
{{out}}
<pre>(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</pre>
=={{header|EchoLisp}}==
Complex numbers are part of the language. No special library is needed.
<syntaxhighlight lang="lisp">
(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
</syntaxhighlight>
=={{header|Elixir}}==
<syntaxhighlight lang="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)}"
end
end
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"
end
end
Complex.task</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Erlang}}==
<
%% Author: Abhay Jain
Line 1,167 ⟶ 1,679:
true ->
io:format("Ans = ~p+~pi~n", [A#complex.real, A#complex.img])
end. </
{{out}}
<
Ans = -1+17i
Ans = -1-3i
Ans = 0.1-0.3i
Ans = 1-3i</
=={{header|ERRE}}==
<syntaxhighlight lang="text">
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
</syntaxhighlight>
Note: Adapted from QuickBasic source code
{{out}}
<pre> 3 + 3 i
0 + 4 i
.5 +-.5 i
-1 +-1 i</pre>
=={{header|Euler Math Toolbox}}==
<syntaxhighlight lang="euler math toolbox">
>a=1+4i; b=5-3i;
>a+b
Line 1,191 ⟶ 1,761:
>conj(a)
1-4i
</syntaxhighlight>
=={{header|Euphoria}}==
<
type complex(sequence s)
return length(s) = 2 and atom(s[REAL]) and atom(s[IMAG])
Line 1,252 ⟶ 1,821:
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))})</
{{out}}
<pre>a = 1+i
b = 3.14159+1.2i
Line 1,266 ⟶ 1,835:
C1:
<
=IMSUM(A1;B1)
</syntaxhighlight>
D1:
<
=IMPRODUCT(A1;B1)
</syntaxhighlight>
E1:
<
=IMSUB(0;D1)
</syntaxhighlight>
F1:
<
=IMDIV(1;E28)
</syntaxhighlight>
G1:
<
=IMCONJUGATE(C28)
</syntaxhighlight>
E1 will have the negation of D1's value
<syntaxhighlight lang="text">
1+2i 3+5i 4+7i -7+11i 7-11i 0,0411764705882353+0,0647058823529412i 4-7i
</syntaxhighlight>
=={{header|F Sharp|F#}}==
Entered into an interactive session to show the results:
<
> open Microsoft.FSharp.Math;;
Line 1,344 ⟶ 1,913:
i = -1.0;
r = -1.0;}
</syntaxhighlight>
=={{header|Factor}}==
<
C{ 1 2 } C{ 0.9 -2.78 } {
Line 1,359 ⟶ 1,928:
C{ 1 2 } {
[ neg . ] ! negation
[
[ conjugate . ] ! complex conjugate
[ sin . ] ! sine
[ log . ] ! natural logarithm
[ sqrt . ] ! square root
} cleave</
=={{header|Forth}}==
{{libheader|Forth Scientific Library}}
<syntaxhighlight lang="forth">S" fsl-util.fs" REQUIRED
zvariable x
Line 1,381 ⟶ 1,948:
x z@ y z@ z+ z.
x z@ y z@ z* z.
1e 0e zconstant 1+0i
1+0i x z@ z/ z.
x z@ znegate z.</
=={{header|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:
<
complex :: a = (5,3), b = (0.5, 6.0) ! complex initializer
complex :: absum, abprod, aneg, ainv
Line 1,394 ⟶ 1,962:
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
<
complex :: a = (5,3), b = (0.5, 6) ! complex initializer
real, parameter :: pi = 3.141592653589793 ! The constant "pi"
Line 1,411 ⟶ 1,979:
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)
Line 1,424 ⟶ 1,992:
! useful for FFT calculations, among other things
unit_circle = exp(2*i*pi/n * (/ (j, j=0, n-1) /) )
end program cdemo2</
=={{header|FreeBASIC}}==
<syntaxhighlight lang="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 = imag
End 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 = "; x
Print "y = "; y
Print "x + y = "; x + y
Print "x - y = "; x - y
Print "x * y = "; x * y
Print "x / y = "; x / y
Print "-x = "; -x
Print "1 / x = "; x.invert
Print "x* = "; x.conjugate
Print
Print "Press any key to quit"
Sleep</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Free Pascal}}==
FreePascal has a complex units. Example of usage:
<syntaxhighlight lang="pascal">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.
</syntaxhighlight>
=={{header|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 + y
multiply[x,y] := x * y
Line 1,442 ⟶ 2,122:
println["1/$a = " + invert[a]]
println["conjugate[$a] = " + conjugate[a]]
</syntaxhighlight>
{{out}}
<pre>
( 3 + 2.5 i ) + ( 7.3 - 10 i ) = ( 10.3 - 7.5 i )
Line 1,452 ⟶ 2,132:
conjugate[( 3 + 2.5 i )] = ( 3 - 2.5 i )
</pre>
=={{header|Futhark}}==
{{incorrect|Futhark|Futhark's syntax has changed, so "fun" should be "let"}}
<syntaxhighlight lang="futhark">
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
</syntaxhighlight>
=={{header|GAP}}==
<
# E(n) is an nth primitive root of 1
i := Sqrt(-1);
Line 1,472 ⟶ 2,184:
# true
Sqrt(-3) in Cyclotomics;
# true</
=={{header|Go}}==
Go has complex numbers built in, with the complex conjugate in the standard library.
<
import (
Line 1,493 ⟶ 2,205:
fmt.Println("1 / a: ", 1/a)
fmt.Println("a̅: ", cmplx.Conj(a))
}</
{{out}}
<pre>
a: (1+1i)
Line 1,507 ⟶ 2,219:
=={{header|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:
<
final Number real, imag
static final Complex
Complex(Number
Complex(Map that) { (real, 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
/** the magnitude of this complex number. */
Number abs() { this.abs }
/** the reciprocal of this complex number. */
Complex getRecip() { (~this) / (ρ**2) }
Complex recip() { this.recip }
/** derived polar angle θ (theta) for polar form. Normalized to 0 ≤ θ < 2π. */
Number getTheta() {
def
}
/** 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,
static Complex fromPolar(Number
[
}
/** Creates new complex with same magnitude
Complex withTheta(Number
/** 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 == zero && c !=
? zero \
: c == 1 \
? this \
: exp( log(this) * c )
}
Complex power(Number n) { this ** ([n, 0] as Complex) }
boolean equals(
? [this.real, this.imag] == [
:
}
int hashCode() { [real, imag].hashCode() }
String toString() {
def realPart = "${real}"
Line 1,600 ⟶ 2,319:
: realPart + (imag > 0 ? " + " : " - ") + imagPart
}
}</
The following ''ComplexCategory'' class allows for modification of regular ''Number'' behavior when interacting with ''Complex''.
<syntaxhighlight lang="groovy">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 <N extends Number,T> T asType (N a, Class<T> type) {
type == Complex \
? [a as Number] as Complex
: DefaultGroovyMethods.asType(a, type)
}
}</syntaxhighlight>
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):
<syntaxhighlight lang="groovy">import static Complex.*
Number.metaClass.mixin ComplexCategory
Integer.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 Complex
def a1 = [real:5, imag:3] as Complex
def a2 = 5 + 3.i
def a3 = 5 + 3*i
assert a == a1 && a == a2 && a == a3
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
println "1/a == (${a}).recip
println "a * 1/a == " + (a * a.recip)
println()
println 'Demo 2: other functionality not requested, but important for completeness'
def c = 10
def d = 10 as Complex
assert d instanceof Complex && c instanceof Number && d == c
assert a + c == c + a
println "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 * c
println "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.real
println 'a.imag == ' + a.imag
println '|a| == ' + a.abs
println 'a.rho == ' + a.rho
println 'a.ρ == ' + a.ρ
println 'a.theta == ' + a.theta
println '
println '
def
def
def
def θ = π / n
def fromPolar1 = fromPolar(ρ, θ) // direct polar-to-cartesian conversion
def fromPolar2 = exp(θ.i) * ρ // Euler's equation
println "ρ*cos(θ) + i*ρ*sin(θ) == ${ρ}*cos(π/${n}) + i*${ρ}*sin(π/${n})"
println " == 10*0.5 + i*10*√(3/4) == " + fromPolar1
println "ρ*exp(i*θ) == ${ρ}*exp(i*π/${n}) == " + fromPolar2
assert (fromPolar1 - fromPolar2).abs < ε</syntaxhighlight>
{{out}}
<pre>Demo 1: functionality as requested
a == 5 + 3i
Line 1,648 ⟶ 2,414:
a * b == (5 + 3i) * (0.5 + 6i) == -15.5 + 31.5i
-a == -(5 + 3i) == -5 - 3i
1/a == (5 + 3i).recip
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
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.013750112198456853 - 0.09332524760169052i
a.real == 5
a.imag == 3
|a| == 5.830951894845301
a.rho == 5.830951894845301
a.ρ == 5.830951894845301
a.theta == 0.5404195002705842
ρ*exp(i*θ) == 10*exp(i*π/3) == 5.000000000000001 + 8.660254037844386i</pre>
=={{header|Hare}}==
<syntaxhighlight lang="hare">use fmt;
use math::complex::{c128,addc128,mulc128,divc128,negc128,conjc128};
export fn main() void = {
let x: c128 = (1.0, 1.0);
let y: c128 = (3.14159265, 1.2);
// addition
let (re, im) = addc128(x, y);
fmt::printfln("{} + {}i", re, im)!;
// multiplication
let (re, im) = mulc128(x, y);
fmt::printfln("{} + {}i", re, im)!;
// inversion
let (re, im) = divc128((1.0, 0.0), x);
fmt::printfln("{} + {}i", re, im)!;
// negation
let (re, im) = negc128(x);
fmt::printfln("{} + {}i", re, im)!;
// conjugate
let (re, im) = conjc128(x);
fmt::printfln("{} + {}i", re, im)!;
};</syntaxhighlight>
=={{header|Haskell}}==
Line 1,670 ⟶ 2,469:
have ''Complex Integer'' for the Gaussian Integers, ''Complex Float'', ''Complex Double'', etc. The operations are just the usual overloaded numeric operations.
<
main = do
Line 1,683 ⟶ 2,482:
putStrLn $ "Negate: " ++ show (-a)
putStrLn $ "Inverse: " ++ show (recip a)
putStrLn $ "Conjugate:" ++ show (conjugate a)</
{{out}}
<pre>*Main> main
Add: 5.0 :+ 2.0
Subtract: (-3.0) :+ 2.0
Line 1,694 ⟶ 2,492:
Negate: (-1.0) :+ (-2.0)
Inverse: 0.2 :+ (-0.4)
Conjugate:1.0 :+ (-2.0)</
=={{header|Icon}} and {{header|Unicon}}==
Icon doesn't provide native support for complex numbers. Support is included in the IPL.
Note: see the [[Arithmetic/Complex#Unicon|Unicon]] section below for a Unicon-specific solution.
<syntaxhighlight lang="icon">procedure main()
SetupComplex()
Line 1,734 ⟶ 2,518:
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.
{{libheader|Icon Programming Library}}
[http://www.cs.arizona.edu/icon/library/src/procs/complex.icn provides complex number support] supplemented by the code below.
<syntaxhighlight lang="icon">
link complex # for complex number support
Line 1,766 ⟶ 2,550:
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.
{{out}}
<pre>#complexdemo.exe
Line 1,787 ⟶ 2,572:
neg(1) := (-1.0+0.0i)</pre>
=={{header|IDL}}==
<tt>complex</tt> (and <tt>dcomplex</tt> for double-precision) is a built-in data type in IDL:
<syntaxhighlight 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)</syntaxhighlight>
=={{header|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.
<
y=: 3.14159j1.2
x+y NB. addition
4.14159j2.2
x*y NB. multiplication
1.94159j4.34159
%x NB. inversion
0.5j_0.5
-x NB. negation
_1j_1
+x NB. (complex) conjugation
1j_1
</syntaxhighlight>
=={{header|Java}}==
<
public final double real;
public final double imag;
public Complex() {
this(0, 0);
}
public Complex
imag = i;
}
public Complex
return new Complex(this.real + b.real, this.imag + b.imag);
}
public Complex
//
}
public Complex
// 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
return new Complex(-real, -imag);
}
public
}
@Override
public String toString() {
return real + " + " + imag + " * i";
}
public static void main(String[] args) {
Complex a = new Complex(Math.PI, -5); //just some numbers
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());
}
}</syntaxhighlight>
=={{header|JavaScript}}==
<
this.r = r;
this.i = i;
Line 1,903 ⟶ 2,712:
Complex.prototype.getMod = function() {
return Math.sqrt( Math.pow(this.r,2) , Math.pow(this.i,2) )
}</
=={{header|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.<syntaxhighlight lang="jq">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] )</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="jq">$ 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]"</syntaxhighlight>
=={{header|Julia}}==
Julia has built-in support for complex arithmetic with arbitrary real types.
<
julia> z2 = 1.5 + 1.5im
julia> z1 + z2
Line 1,928 ⟶ 2,816:
1.5
julia> imag(z1)
3.0</
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">class Complex(private val real: Double, private val imag: Double) {
operator fun plus(other: Complex) = Complex(real + other.real, imag + other.imag)
operator fun times(other: Complex) = Complex(
real * other.real - imag * other.imag,
real * other.imag + imag * other.real
)
fun inv(): Complex {
val denom = real * real + imag * imag
return Complex(real / denom, -imag / denom)
}
operator fun unaryMinus() = Complex(-real, -imag)
operator fun minus(other: Complex) = this + (-other)
operator fun div(other: Complex) = this * other.inv()
fun conj() = Complex(real, -imag)
override fun toString() =
if (imag >= 0.0) "$real + ${imag}i"
else "$real - ${-imag}i"
}
fun main(args: Array<String>) {
val x = Complex(1.0, 3.0)
val y = Complex(5.0, 2.0)
println("x = $x")
println("y = $y")
println("x + y = ${x + y}")
println("x - y = ${x - y}")
println("x * y = ${x * y}")
println("x / y = ${x / y}")
println("-x = ${-x}")
println("1 / x = ${x.inv()}")
println("x* = ${x.conj()}")
}</syntaxhighlight>
{{out}}
<pre>
x = 1.0 + 3.0i
y = 5.0 + 2.0i
x + y = 6.0 + 5.0i
x - y = -4.0 + 1.0i
x * y = -1.0 + 17.0i
x / y = 0.3793103448275862 + 0.4482758620689655i
-x = -1.0 - 3.0i
1 / x = 0.1 - 0.3i
x* = 1.0 - 3.0i
</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{require lib_complex}
{def z1 {C.new 1 1}}
-> z1 = (1 1)
{C.x {z1}} -> 1
{C.y {z1}} -> 1
{C.mod {z1}} -> 1.4142135623730951
{C.arg {z1}} -> 0.7853981633974483 // 45°
{C.conj {z1}} -> (1 -1)
{C.negat {z1}} -> (-1 -1)
{C.invert {z1}} -> (0.5 -0.4999999999999999)
{C.sqrt {z1}} -> (1.0986841134678098 0.45508986056222733)
{C.exp {z1}} -> (1.4686939399158851 2.2873552871788423)
{C.log {z1}} -> (0.3465735902799727 0.7853981633974483)
{def z2 {C.new 1.5 1.5}}
-> z2 = (1.5 1.5)
{C.add {z1} {z2}} -> (2.5 2.5)
{C.sub {z1} {z2}} -> (-0.5 -0.5)
{C.mul {z1} {z2}} -> (0 3)
{C.div {z1} {z2}} -> (0.6666666666666667 0)
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
fp.cprint = ($z) -> fn.printf(%.3f%+.3fi%n, fn.creal($z), fn.cimag($z))
$a = fn.complex(1.5, 3)
$b = fn.complex(1.5, 1.5)
fn.print(a =\s)
fp.cprint($a)
fn.print(b =\s)
fp.cprint($b)
# Addition
fn.print(a + b =\s)
fp.cprint(fn.cadd($a, $b))
# Multiplication
fn.print(a * b =\s)
fp.cprint(fn.cmul($a, $b))
# Inversion
fn.print(1/a =\s)
fp.cprint(fn.cdiv(fn.complex(1, 0), $a))
# Negation
fn.print(-a =\s)
fp.cprint(fn.cinv($a))
# Conjugate
fn.print(conj(a) =\s)
fp.cprint(fn.conj($a))
</syntaxhighlight>
{{out}}
<pre>
a = 1.500+3.000i
b = 1.500+1.500i
a + b = 3.000+4.500i
a * b = -2.250+6.750i
1/a = 0.133-0.267i
-a = -1.500-3.000i
conj(a) = 1.500-3.000i
</pre>
=={{header|LFE}}==
There is no native support for complex numbers in either LFE or Erlang. As such, this example shows how to implement complex support. There is, however, an LFE library that offers a complex number data type and many mathematical functions which support this data type: [https://github.com/lfex/complex complex].
A convenient data structure for a complex number is the record:
<syntaxhighlight lang="lisp">
(defrecord complex
real
img)
</syntaxhighlight>
Here are the required functions:
<syntaxhighlight lang="lisp">
(defun add
(((match-complex real r1 img i1)
(match-complex real r2 img i2))
(new (+ r1 r2) (+ i1 i2))))
(defun mult
(((match-complex real r1 img i1)
(match-complex real r2 img i2))
(new (- (* r1 r2) (* i1 i2))
(+ (* r1 i2) (* r2 i1)))))
(defun neg
(((match-complex real r img i))
(new (* -1 r) (* -1 i))))
(defun inv (cmplx)
(div (conj cmplx) (modulus cmplx)))
</syntaxhighlight>
Bonus:
<syntaxhighlight lang="lisp">
(defun conj
(((match-complex real r img i))
(new r (* -1 i))))
</syntaxhighlight>
The functions above are built using the following supporting functions:
<syntaxhighlight lang="lisp">
(defun new (r i)
(make-complex real r img i))
(defun modulus (cmplx)
(mult cmplx (conj cmplx)))
(defun div (c1 c2)
(let* ((denom (complex-real (modulus c2)))
(c3 (mult c1 (conj c2))))
(new (/ (complex-real c3) denom)
(/ (complex-img c3) denom)))))
</syntaxhighlight>
Finally, we have some functions for use in the conversion and display of our complex number data structure:
<syntaxhighlight lang="lisp">
(defun ->str
(((match-complex real r img i)) (when (>= i 0))
(->str r i "+"))
(((match-complex real r img i))
(->str r i "")))
(defun ->str (r i pos)
(io_lib:format "~p ~s~pi" `(,r ,pos ,i)))
(defun print (cmplx)
(io:format (++ (->str cmplx) "~n")))
</syntaxhighlight>
Usage is as follows:
<pre>
> (set ans1 (add c1 c2))
#(complex 2.5 4.0)
> (set ans2 (mult c1 c2))
#(complex -1.5 4.5)
> (set ans3 (inv c2))
#(complex 0.5 -0.5)
> (set ans4 (conj c1))
#(complex 1.5 -3.0)
</pre>
These can be printed in the following manner:
<pre>
> (progn (lists:map #'print/1 `(,ans1 ,ans2 ,ans3 ,ans4)) 'ok)
2.5 +4.0i
-1.5 +4.5i
0.5 -0.5i
1.5 -3.0i
ok
</pre>
=={{header|Liberty BASIC}}==
<
print " Adding"
Line 1,980 ⟶ 3,092:
D =ar^2 +ai^2
cinv$ =complex$( ar /D , 0 -ai /D )
end function</
=={{header|Lua}}==
<
--defines addition, subtraction, negation, multiplication, division, conjugation, norms, and a conversion to strgs.
Line 2,016 ⟶ 3,128:
print("|" .. i .. "| = " .. math.sqrt(i.norm))
print(i .. "* = " .. i.conj)
</syntaxhighlight>
=={{header|Maple}}==
Line 2,022 ⟶ 3,134:
Maple has <code>I</code> (the square root of -1) built-in. Thus:
<
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:
<
==> (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;
1/x;</
=={{header|Mathematica}} / {{header|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:
<
y=3+4I
Line 2,051 ⟶ 3,163:
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!):
<
Sin Cos Tan Csc Sec Cot
ArcSin ArcCos ArcTan ArcCsc ArcSec ArcCot
Line 2,062 ⟶ 3,174:
Haversine InverseHaversine
Factorial Gamma PolyGamma LogGamma
Erf BarnesG Hyperfactorial Zeta ProductLog RamanujanTauL</
and many many more. The documentation states:
Line 2,070 ⟶ 3,182:
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 =
Line 2,128 ⟶ 3,240:
ans =
1.414213562373095</
=={{header|Maxima}}==
<
2*%i+5
Line 2,174 ⟶ 3,286:
imagpart(z1);
2</
=={{header|МК-61/52}}==
''Instrustion:''
Z<sub>1</sub> = a + ib; Z<sub>2</sub> = c + id;
a С/П b С/П c С/П d С/П
Division: С/П; multiplication: БП 36 С/П; addition: БП 54 С/П; subtraction: БП 63 С/П.
<syntaxhighlight lang="text">П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 С/П</syntaxhighlight>
=={{header|Modula-2}}==
<
IMPORT InOut;
Line 2,243 ⟶ 3,372:
NegComplex (z[0], z[2]); ShowComplex (" - z1", z[2]);
InOut.WriteLn
END complex.</syntaxhighlight>
{{out}}
<pre>Enter two complex numbers : 5 3 0.5 6
z1 = 5.00 + 3.00 i
z2 = 0.50 + 6.00 i
Line 2,252 ⟶ 3,383:
1 / z1 = 0.15 - 0.09 i
- z1 = -5.00 - 3.00 i</pre>
=={{header|Nanoquery}}==
{{trans|Java}}
This is a translation of the Java version, but it uses operator redefinition where possible.
<syntaxhighlight lang="nanoquery">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"
end
end
a = new(Complex, math.pi, -5)
b = new(Complex, -1, 2.5)
println a.neg()
println a + b
println a.inv()
println a * b
println a.conj()</syntaxhighlight>
=={{header|Nemerle}}==
<
using System.Console;
using System.Numerics;
Line 2,279 ⟶ 3,470:
WriteLine(Conjugate(complex2).PrettyPrint());
}
}</
{{out}}
<pre>4.14159 + 2.2i
1.94159 + 4.34159i
Line 2,287 ⟶ 3,478:
3.14159 - 1.2i</pre>
=={{header|
<syntaxhighlight lang="nim">
import complex
var a:
var b:
echo
echo
echo
echo
echo
echo
</syntaxhighlight>
{{out}}
<pre>
a : (1.0000000000000000e+00, 1.0000000000000000e+00)
Line 2,313 ⟶ 3,504:
=={{header|Oberon-2}}==
Oxford Oberon Compiler
<
MODULE Complex;
IMPORT Files,Out;
Line 2,399 ⟶ 3,590:
END Complex.
</syntaxhighlight>
{{out}}
<pre>
x: (1.50000,3.00000i)
Line 2,414 ⟶ 3,605:
=={{header|OCaml}}==
The [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Complex.html Complex] module from the standard library provides the functionality of complex numbers:
<
let print_complex z =
Line 2,426 ⟶ 3,617:
print_complex (inv a);
print_complex (neg a);
print_complex (conj a)</
Using [http://forge.ocamlcore.org/projects/pa-do/ Delimited Overloading], the syntax can be made closer to the usual one:
<
Complex.(
let print txt z = Printf.printf "%s = %s\n" txt (to_string z) in
Line 2,442 ⟶ 3,633:
print "a^b" (a**b);
Printf.printf "norm a = %g\n" (float(abs a));
)</
=={{header|Octave}}==
GNU Octave handles naturally complex numbers:
<
z2 = 1.5 + 1.5i;
disp(z1 + z2); % 3.0 + 4.5i
Line 2,459 ⟶ 3,650:
disp( imag(z1) ); % 3
disp( real(z2) ); % 1.5
%...</
=={{header|Oforth}}==
<syntaxhighlight lang="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 ;</syntaxhighlight>
Usage :
<syntaxhighlight lang="oforth">3.2 >complex I * 2 >complex + .cr
2 3 Complex new 1.2 >complex + .cr
2 3 Complex new 1.2 >complex * .cr
2 >complex 2 3 Complex new / .cr</syntaxhighlight>
{{out}}
<pre>
(2,3.2)
(3.2,3)
(2.4,3.6)
(0.307692307692308,-0.461538461538462)
</pre>
=={{header|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`.
<syntaxhighlight lang="scheme">
(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
</syntaxhighlight>
=={{header|ooRexx}}==
<syntaxhighlight lang="oorexx">c1 = .complex~new(1, 2)
c2 = .complex~new(3, 4)
r = 7
Line 2,583 ⟶ 3,859:
-- 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
else
forward message("ADD")
Line 2,599 ⟶ 3,875:
::method hashCode
expose r i
return r~hashcode~bitxor(i~hashcode)</syntaxhighlight>
{{out}}
<pre>c1 = 1 + 2i
c2 = 3 + 4i
r = 7
Line 2,618 ⟶ 3,892:
c1 / c2 = 0.44 + 0.08i
c1 == c1 = 1
c1 == c2 = 0
=={{header|OxygenBasic}}==
Implementation of a complex numbers class with arithmetical operations, and powers using DeMoivre's theorem (polar conversion).
<
'COMPLEX OPERATIONS
'=================
Line 2,756 ⟶ 4,029:
z1 = z1*z4
print "Z1 = "+z1.show 'RESULT 2.0, 1.0
</syntaxhighlight>
=={{header|PARI/GP}}==
To use, type, e.g., inv(3 + 7*I).
<
mult(a,b)=a*b;
neg(a)=-a;
inv(a)=1/a;</
=={{header|Pascal}}==
{{works with|Extended Pascal}}
The simple data type <tt>complex</tt> is part of Extended Pascal, ISO standard 10206.
<syntaxhighlight lang="pascal">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 }
begin
sum := x + y
end;
function product(protected x, y: complex): complex;
product := x * y
end;
negative := -x
inverse := x ** negativeOne
end;
{ 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)
{ --- 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 := result
end;
{ === 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.</syntaxhighlight>
{{out}}
<pre>(-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)</pre>
The GPC, GNU Pascal Compiler, supports Extended Pascal’s <tt>complex</tt> data type and operations as shown.
Furthermore, the GPC defines a function <tt>conjugate</tt> so there is no need for writing such a custom function.
The PXSC, Pascal eXtensions for scientific computing, define a standard data type similar to [[#Free Pascal|Free Pascal’s]] <tt>ucomplex</tt> data type.
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
begin
var a
var b
Println(a - b);
Println(a / b);
Println(1/a);
Println(a.Real,a.Imaginary);
Println(a.Conjugate);
Println(a ** b);
end.
</syntaxhighlight>
{{out}}
<pre>
4+6i
-2-2i
-5+10i
0.44+0.08i
-1-2i
0.2-0.4i
1 2
1-2i
2.23606797749979
0.129009594074467+0.0339240929051702i
</pre>
=={{header|Perl}}==
The <code>Math::Complex</code> module implements complex arithmetic.
<
my $a = 1 + 1*i;
my $b = 3.14159 + 1.25*i;
Line 2,877 ⟶ 4,161:
-$a, # negation
1 / $a, # multiplicative inverse
~$a; # complex conjugate</
=={{header|
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\ArithComplex.exw</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">complex</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">complex</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">complex_new</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">),</span> <span style="color: #000080;font-style:italic;">-- (or just {1,1})</span>
<span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">complex_new</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3.14159</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1.25</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">complex_new</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">complex_new</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"a = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"b = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"c = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"d = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">d</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"a+b = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"a*b = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1/a = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_inv</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"c/a = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"c-a = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"d-a = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">d</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"-a = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_neg</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"conj a = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_conjugate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">))})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
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
</pre>
=={{header|PicoLisp}}==
<
(de addComplex (A B)
Line 2,965 ⟶ 4,243:
(prinl "A*B = " (fmtComplex (mulComplex A B)))
(prinl "1/A = " (fmtComplex (invComplex A)))
(prinl "-A = " (fmtComplex (negComplex A))) )</
{{out}}
<pre>A = 1.00000+1.00000i
B = 3.14159+1.20000i
Line 2,973 ⟶ 4,251:
1/A = 0.50000-0.50000i
-A = -1.00000-1.00000i</pre>
=={{header|PL/I}}==
<syntaxhighlight lang="pli">/* 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. */</syntaxhighlight>
=={{header|Pop11}}==
Line 2,985 ⟶ 4,286:
'1 -: 3' is '1 - 3i' in mathematical notation.
<
a+b =>
a*b =>
Line 3,003 ⟶ 4,304:
a-a =>
a/b =>
a/a =></
=={{header|PostScript}}==
Complex numbers can be represented as 2 element vectors ( arrays ). Thus, a+bi can be written as [a b] in PostScript.
<syntaxhighlight lang="text">
%Adding two complex numbers
/addcomp{
Line 3,055 ⟶ 4,357:
}def
</syntaxhighlight>
=={{header|PowerShell}}==
===Implementation===
<syntaxhighlight lang="powershell">
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()))"
</syntaxhighlight>
<b>Output:</b>
<pre>
$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
</pre>
===Library===
<syntaxhighlight lang="powershell">
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)))"
</syntaxhighlight>
<b>Output:</b>
<pre>
$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
</pre>
=={{header|PureBasic}}==
<
real.d
imag.d
Line 3,122 ⟶ 4,507:
*c=Neg_Complex(a): ShowAndFree("-a", *c)
Print(#CRLF$+"Press ENTER to exit"):Input()
EndIf</
=={{header|Python}}==
<
>>> z2 = 1.5 + 1.5j
>>> z1 + z2
Line 3,148 ⟶ 4,533:
>>> z1.imag
3.0
>>> </
=={{header|R}}==
{{trans|Octave}}
<
z2 <- 1.5 + 1.5i
print(z1 + z2) # 3+4.5i
Line 3,165 ⟶ 4,550:
print(exp(z1)) # -4.436839+0.632456i
print(Re(z1)) # 1.5
print(Im(z1)) # 3</
=={{header|Racket}}==
<
#lang racket
Line 3,182 ⟶ 4,567:
(/ 1 a) ; reciprocal
(conjugate a) ; conjugation
</syntaxhighlight>
=={{header|
(formerly Perl 6)
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang="raku" line>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;</syntaxhighlight>
{{out}} (precision varies with different implementations):
<pre>
4.1415926535897931+2.25i
1.8915926535897931+4.3915926535897931i
-1-1i
0.5-0.5i
1-1i
1.4142135623730951
1.0986841134678098+0.45508986056222733i
1
1
</pre>
=={{header|REXX}}==
The REXX language has no complex type numbers, but most complex arithmetic functions can easily be written.
<syntaxhighlight lang="rexx">/*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; return
C$: parse arg r,c; _='['r; if c\=0 then _=_","c'j'; return _"]" /*uses j */</syntaxhighlight>
'''output'''
<pre>
addition: (5,3i) + ( .5, 6j) = [5.5,9j]
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]
</pre>
=={{header|RLaB}}==
<syntaxhighlight lang="rlab">
>> x = sqrt(-1)
0 + 1i
Line 3,233 ⟶ 4,638:
>> isreal(z)
1
</syntaxhighlight>
=={{header|RPL}}==
{{in}}
<pre>
(1.5,3) 'Z1' STO
(1.5,1.5) 'Z2' STO
Z1 Z2 +
Z1 Z2 -
Z1 Z2 *
Z1 Z2 /
Z1 NEG
Z1 CONJ
Z1 ABS
Z1 RE
Z1 IM
</pre>
{{out}}
<pre>
(3,4.5)
(0,1.5)
(-2.25,6.75)
(1.5,.5)
(-1.5,-3)
(1.5,-3)
63.4349488229
1.5
3
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">
# Four ways to write complex numbers:
a = Complex(1, 1) # 1. call Kernel#Complex
i = Complex::I # 2. use Complex::I
b = 3.14159 + 1.25 * i
c = '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)
Line 3,253 ⟶ 4,682:
puts 1.quo a # multiplicative inverse
puts a.conjugate # complex conjugate
puts a.conj # alias for complex conjugate</
''Notes:''
* All of these operations are safe with other numeric types. For example, <code>42.conjugate</code> returns 42.
<
puts 1.quo a # always works
puts 1.0 / a # works, but forces floating-point math
puts 1 / a # might truncate to integer</
=={{header|Rust}}==
<syntaxhighlight lang="rust">extern crate num;
use num::complex::Complex;
fn main() {
// two valid forms of definition
let
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 = {}",
println!(" -a = {}", -a);
println!("conj
}</
=={{header|Scala}}==
Line 3,288 ⟶ 4,714:
Scala doesn't come with a Complex library, but one can be made:
<
package object ArithmeticComplex {
Line 3,322 ⟶ 4,748:
def fromPolar(rho:Double, theta:Double) = Complex(rho*math.cos(theta), rho*math.sin(theta))
}
}</
Usage example:
<
import org.rosettacode.ArithmeticComplex._
Line 3,352 ⟶ 4,778:
scala> -res6
res7: org.rosettacode.ArithmeticComplex.Complex = -0.2 + 0.4i
</syntaxhighlight>
=={{header|Scheme}}==
Line 3,358 ⟶ 4,784:
* rectangular coordinates: <code>''real''+''imag''i</code> (or <code>''real''-''imag''i</code>), 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 "+"): <code>+''imag''i</code> (or <code>-''imag''i</code>). If the imaginary part is 1 or -1, the imaginary part can be omitted, leaving only the <code>+i</code> or <code>-i</code> at the end.
* polar coordinates: <code>''r''@''theta''</code>, where ''r'' is the absolute value (magnitude) and ''theta'' is the angle
<
(define b 3.14159+1.25i)
Line 3,364 ⟶ 4,790:
(define c (* a b))
(define c (/ 1 a))
(define c (- a))</
=={{header|Seed7}}==
<
include "float.s7i";
include "complex.s7i";
Line 3,387 ⟶ 4,813:
# negation
writeln("-a=" <& -a digits 5);
end func;</
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var a = 1:1 # Complex(1, 1)
var b = 3.14159:1.25 # Complex(3.14159, 1.25)
[ a + b, # addition
a * b, # multiplication
-a, # negation
a.inv, # multiplicative inverse
a.conj, # complex conjugate
a.abs, # abs
a.sqrt, # sqrt
b.re, # real
b.im, # imaginary
].each { |c| say c }</syntaxhighlight>
{{out}}
<pre>4.14159+2.25i
1.89159+4.39159i
-1-i
0.5-0.5i
1-i
1.4142135623730950488016887242097
1.09868411346780996603980119524068+0.45508986056222734130435775782247i
3.14159
1.25</pre>
=={{header|Slate}}==
<
a: 1 + 1 i.
b: Pi + 1.2 i.
Line 3,401 ⟶ 4,852:
print: a abs.
print: a negated.
].</
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<
|a b|
a := 1 + 1 i.
Line 3,417 ⟶ 4,868:
a real displayNl.
a imaginary displayNl.
a negated displayNl.</
{{works with|Smalltalk/X}}
Complex is already in the basic class library. Multiples of imaginary are created by sending an "i" message to a number, which can be added to another number. Thus 5i => (0+5i), 1+(1/3)I => (1+1/3i) and (1.0+2i) => (1.0+2i). Notice that the real and imaginary components can be arbitrary integers, fractions or floating point numbers. And the results will be exact (i.e. have fractions or integer) if possible.
<syntaxhighlight lang="smalltalk">
|a b|
a := 1 + 1i.
b := 3.14159 + 1.2i.
Transcript show:'a => '; showCR:a.
Transcript show:'b => '; showCR:b.
Transcript show:'a+b => '; showCR:(a + b).
Transcript show:'a-b => '; showCR:(a - b).
Transcript show:'a*b => '; showCR:(a * b).
Transcript show:'a/b => '; showCR:(a / b).
Transcript show:'a reciprocal => '; showCR:a reciprocal.
Transcript show:'a conjugated => '; showCR:a conjugated.
Transcript show:'a abs => '; showCR:a abs.
Transcript show:'a real => '; showCR:a real.
Transcript show:'a imaginary => '; showCR:a imaginary.
Transcript show:'a negated => '; showCR:a negated.
Transcript show:'a sqrt => '; showCR:a sqrt.
a2 := (1/2) + 1i.
b2 := (2/3) + 2i.
Transcript show:'a2+b2 => '; showCR:(a2 + b2).
Transcript show:'a2-b2 => '; showCR:(a2 - b2).
Transcript show:'a2*b2 => '; showCR:(a2 * b2).
Transcript show:'a2/b2 => '; showCR:(a2 / b2).
Transcript show:'a2 reciprocal => '; showCR:a2 reciprocal.</syntaxhighlight>
{{out}}
<pre>a => (1+1i)
b => (3.14159+1.2i)
a+b => (4.14159+2.2i)
a-b => (-2.14159-0.2i)
a*b => (1.94159+4.34159i)
a/b => (0.383885788269082+0.171676461306887i)
a reciprocal => ((1/2)-(1/2)i)
a conjugated => (1-1i)
a abs => 1.4142135623731
a real => 1
a imaginary => 1
a negated => (-1-1i)
a sqrt => (1.09868411346781+0.455089860562227i)
a2+b2 => ((7/6)+3i)
a2-b2 => ((-1/6)-1i)
a2*b2 => ((-5/3)+(5/3)i)
a2/b2 => ((21/40)-(3/40)i)
a2 reciprocal => ((2/5)-(4/5)i)</pre>
=={{header|smart BASIC}}==
<b>Original author unknown {:o(</b>
<syntaxhighlight lang="qbasic">' complex numbers are native for "smart BASIC"
A=1+2i
B=3-5i
' all math operations and functions work with complex numbers
C=A*B
PRINT SQR(-4)
' example of solving quadratic equation with complex roots
' x^2+2x+5=0
a=1 ! b=2 ! c=5
x1=(-b+sqr(b^2-4*a*c))/(2*a)
x2=(-b-sqr(b^2-4*a*c))/(2*a)
print x1,x2
' gives output
-1+2i -1-2i</syntaxhighlight>
=={{header|SNOBOL4}}==
Line 3,425 ⟶ 4,943:
{{works with|CSnobol}}
<
data('complex(r,i)')
Line 3,464 ⟶ 4,982:
output = printx( negx(a) ) ', ' printx( negx(b) )
output = printx( invx(a) ) ', ' printx( invx(b) )
end</
{{out}}
<pre>4.14159+2.2i
1.94159+4.34159i
Line 3,473 ⟶ 4,991:
=={{header|Standard ML}}==
<syntaxhighlight lang="standard ml">
(* Signature for complex numbers *)
signature COMPLEX = sig
Line 3,517 ⟶ 5,035:
Complex.print_number(Complex.times i1 i2); (* -5 + 10i *)
Complex.print_number(Complex.invert i1); (* 1/5 - 2i/5 *)
</syntaxhighlight>
=={{header|Stata}}==
<syntaxhighlight lang="stata">mata
C(2,3)
2 + 3i
a=2+3i
b=1-2*i
a+b
-5 + 3i
a-b
9 + 3i
a*b
-14 - 21i
a/b
-.285714286 - .428571429i
-a
-2 - 3i
1/a
.153846154 - .230769231i
conj(a)
2 - 3i
abs(a)
3.605551275
arg(a)
.9827937232
exp(a)
-7.31511009 + 1.04274366i
log(a)
1.28247468 + .982793723i
end</syntaxhighlight>
=={{header|Swift}}==
{{works with|Swift | 2.0 }}
Use a struct to create a complex number type in Swift. Math Operations can be added using operator overloading
<syntaxhighlight lang="swift">
public struct Complex {
public let real : Double
public let imaginary : Double
public init(real inReal:Double, imaginary inImaginary:Double) {
real = inReal
imaginary = inImaginary
}
public static var i : Complex = Complex(real:0, imaginary: 1)
public static var zero : Complex = Complex(real: 0, imaginary: 0)
public var negate : Complex {
return Complex(real: -real, imaginary: -imaginary)
}
public var invert : Complex {
let d = (real*real + imaginary*imaginary)
return Complex(real: real/d, imaginary: -imaginary/d)
}
public var conjugate : Complex {
return Complex(real: real, imaginary: -imaginary)
}
}
public func + (left: Complex, right: Complex) -> Complex {
return Complex(real: left.real+right.real, imaginary: left.imaginary+right.imaginary)
}
public func * (left: Complex, right: Complex) -> Complex {
return Complex(real: left.real*right.real - left.imaginary*right.imaginary,
imaginary: left.real*right.imaginary+left.imaginary*right.real)
}
public prefix func - (right:Complex) -> Complex {
return right.negate
}
// Checking equality is almost necessary for a struct of this type to be useful
extension Complex : Equatable {}
public func == (left:Complex, right:Complex) -> Bool {
return left.real == right.real && left.imaginary == right.imaginary
}
</syntaxhighlight>
Make the Complex Number struct printable and easier to debug by adding making it conform to CustomStringConvertible
<syntaxhighlight lang="swift">
extension Complex : CustomStringConvertible {
public var description : String {
guard real != 0 || imaginary != 0 else { return "0" }
let rs : String = real != 0 ? "\(real)" : ""
let iS : String
let sign : String
let iSpace = real != 0 ? " " : ""
switch imaginary {
case let i where i < 0:
sign = "-"
iS = i == -1 ? "i" : "\(-i)i"
case let i where i > 0:
sign = real != 0 ? "+" : ""
iS = i == 1 ? "i" : "\(i)i"
default:
sign = ""
iS = ""
}
return "\(rs)\(iSpace)\(sign)\(iSpace)\(iS)"
}
}
</syntaxhighlight>
Explicitly support subtraction and division
<syntaxhighlight lang="swift">
public func - (left:Complex, right:Complex) -> Complex {
return left + -right
}
public func / (divident:Complex, divisor:Complex) -> Complex {
let rc = divisor.conjugate
let num = divident * rc
let den = divisor * rc
return Complex(real: num.real/den.real, imaginary: num.imaginary/den.real)
}
</syntaxhighlight>
=={{header|Tcl}}==
{{tcllib|math::complexnumbers}}
<
namespace import math::complexnumbers::*
Line 3,529 ⟶ 5,192:
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</
=={{header|TI-83 BASIC}}==
Line 3,564 ⟶ 5,227:
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.
=={{header|Unicon}}==
Takes advantage of Unicon's operator overloading extension and Unicon's Complex class. Negation is not supported by the Complex class.
<syntaxhighlight lang="unicon">import math
procedure main()
write("c1: ",(c1 := Complex(1.5,3)).toString())
write("c2: ",(c2 := Complex(1.5,1.5)).toString())
write("+: ",(c1+c2).toString())
write("-: ",(c1-c2).toString())
write("*: ",(c1*c2).toString())
write("/: ",(c1/c2).toString())
write("additive inverse: ",c1.addInverse().toString())
write("multiplicative inverse: ",c1.multInverse().toString())
write("conjugate of (4,-3i): ",Complex(4,-3).conjugate().toString())
end</syntaxhighlight>
{{out}}
<pre>c1: (1.5,3i)
c2: (1.5,1.5i)
+: (3.0,4.5i)
-: (0.0,1.5i)
*: (-2.25,6.75i)
/: (1.5,0.5i)
additive inverse: (-1.5,-3i)
multiplicative inverse: (0.1333333333333333,-0.2666666666666667i)
conjugate of (4,-3i): (4,3i)</pre>
=={{header|UNIX Shell}}==
{{works with|ksh93}}
<syntaxhighlight lang="bash">typeset -T Complex_t=(
float real=0
float imag=0
function to_s {
print -- "${_.real} + ${_.imag} i"
}
function dup {
nameref other=$1
_=( real=${other.real} imag=${other.imag} )
}
function add {
typeset varname
for varname; do
nameref other=$varname
(( _.real += other.real ))
(( _.imag += other.imag ))
done
}
function negate {
(( _.real *= -1 ))
(( _.imag *= -1 ))
}
function conjugate {
(( _.imag *= -1 ))
}
function multiply {
typeset varname
for varname; do
nameref other=$varname
float a=${_.real} b=${_.imag} c=${other.real} d=${other.imag}
(( _.real = a*c - b*d ))
(( _.imag = b*c + a*d ))
done
}
function inverse {
if (( _.real == 0 && _.imag == 0 )); then
print -u2 "division by zero"
return 1
fi
float denom=$(( _.real*_.real + _.imag*_.imag ))
(( _.real = _.real / denom ))
(( _.imag = -1 * _.imag / denom ))
}
)
Complex_t a=(real=1 imag=1)
a.to_s # 1 + 1 i
Complex_t b=(real=3.14159 imag=1.2)
b.to_s # 3.14159 + 1.2 i
Complex_t c
c.add a b
c.to_s # 4.14159 + 2.2 i
c.negate
c.to_s # -4.14159 + -2.2 i
c.conjugate
c.to_s # -4.14159 + 2.2 i
c.dup a
c.multiply b
c.to_s # 1.94159 + 4.34159 i
Complex_t d=(real=2 imag=1)
d.inverse
d.to_s # 0.4 + -0.2 i</syntaxhighlight>
=={{header|Ursala}}==
Line 3,573 ⟶ 5,342:
c..add or ..csin). Real operands are promoted to complex.
<
v = 9.545e-01-3.305e+00j
Line 3,584 ⟶ 5,353:
complex..mul (u,v),
complex..sub (0.,u),
complex..div (1.,v)></
{{out}}
<pre><
4.740e+00-5.274e+00j,
Line 3,591 ⟶ 5,360:
3.785e+00-1.969e+00j,
8.066e-02+2.793e-01j></pre>
=={{header|VBA}}==
<syntaxhighlight lang="vba">
Public Type Complex
re As Double
im As Double
End Type
Function CAdd(a As Complex, b As Complex) As Complex
CAdd.re = a.re + b.re
CAdd.im = a.im + b.im
End Function
Function CSub(a As Complex, b As Complex) As Complex
CSub.re = a.re - b.re
CSub.im = a.im - b.im
End Function
Function CMult(a As Complex, b As Complex) As Complex
CMult.re = (a.re * b.re) - (a.im * b.im)
CMult.im = (a.re * b.im) + (a.im * b.re)
End Function
Function CConj(a As Complex) As Complex
CConj.re = a.re
CConj.im = -a.im
End Function
Function CNeg(a As Complex) As Complex
CNeg.re = -a.re
CNeg.im = -a.im
End Function
Function CInv(a As Complex) As Complex
CInv.re = a.re / (a.re * a.re + a.im * a.im)
CInv.im = -a.im / (a.re * a.re + a.im * a.im)
End Function
Function CDiv(a As Complex, b As Complex) As Complex
CDiv = CMult(a, CInv(b))
End Function
Function CAbs(a As Complex) As Double
CAbs = Math.Sqr(a.re * a.re + a.im * a.im)
End Function
Function CSqr(a As Complex) As Complex
CSqr.re = Math.Sqr((a.re + Math.Sqr(a.re * a.re + a.im * a.im)) / 2)
CSqr.im = Math.Sgn(a.im) * Math.Sqr((-a.re + Math.Sqr(a.re * a.re + a.im * a.im)) / 2)
End Function
Function CPrint(a As Complex) As String
If a.im > 0 Then
Sep = "+"
Else
Sep = ""
End If
CPrint = a.re & Sep & a.im & "i"
End Function
Sub ShowComplexCalc()
Dim a As Complex
Dim b As Complex
Dim c As Complex
a.re = 1.5
a.im = 3
b.re = 1.5
b.im = 1.5
Debug.Print "a = " & CPrint(a)
Debug.Print "b = " & CPrint(b)
c = CAdd(a, b)
Debug.Print "a + b = " & CPrint(c)
c = CSub(a, b)
Debug.Print "a - b = " & CPrint(c)
c = CMult(a, b)
Debug.Print "a * b = " & CPrint(c)
c = CConj(a)
Debug.Print "Conj(a) = " & CPrint(c)
c = CNeg(a)
Debug.Print "-a = " & CPrint(c)
c = CInv(a)
Debug.Print "Inv(a) = " & CPrint(c)
c = CDiv(a, b)
Debug.Print "a / b = " & CPrint(c)
Debug.Print "Abs(a) = " & CAbs(a)
c = CSqr(a)
Debug.Print "Sqrt(a) = " & CPrint(c)
End Sub
</syntaxhighlight>
{{out}}
<pre>
a = 1.5+3i
b = 1.5+1.5i
a + b = 3+4.5i
a - b = 0+1.5i
a * b = -2.25+6.75i
Conj(a) = 1.5-3i
-a = -1.5-3i
Inv(a) = 0.133333333333333-0.266666666666667i
a / b = 1.5+0.5i
Abs(a) = 3.35410196624968
Sqrt(a) = 1.55789954205168+0.962834868045836i
</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import math.complex
fn main() {
a := complex.complex(1, 1)
b := complex.complex(3.14159, 1.25)
println("a: $a")
println("b: $b")
println("a + b: ${a+b}")
println("a * b: ${a*b}")
println("-a: ${a.addinv()}")
println("1 / a: ${complex.complex(1,0)/a}")
println("a̅: ${a.conjugate()}")
}</syntaxhighlight>
{{out}}
<pre>a: 1.000000+1.000000i
b: 3.141590+1.250000i
a + b: 4.141590+2.250000i
a * b: 1.891590+4.391590i
-a: -1.000000-1.000000i
1 / a: 0.500000-0.500000i
a̅: 1.000000-1.000000i
</pre>
=={{header|Wortel}}==
{{trans|CoffeeScript}}
<
&[r i] @: {
^r || r 0
Line 3,623 ⟶ 5,522:
"1 / ({b}) = {b.inv.}"
"({!a.mul b}) / ({b}) = {`!.mul b.inv. !a.mul b}"
]</
{{out}}
<pre>(5 + 3i) + (4 - 3i) = 9
(5 + 3i) * (4 - 3i) = 29 - 3i
Line 3,631 ⟶ 5,530:
1 / (4 - 3i) = 0.16 + 0.12i
(29 - 3i) / (4 - 3i) = 5 + 3i</pre>
=={{header|Wren}}==
{{libheader|Wren-complex}}
<syntaxhighlight lang="wren">import "./complex" for Complex
var x = Complex.new(1, 3)
var y = Complex.new(5, 2)
System.print("x = %(x)")
System.print("y = %(y)")
System.print("x + y = %(x + y)")
System.print("x - y = %(x - y)")
System.print("x * y = %(x * y)")
System.print("x / y = %(x / y)")
System.print("-x = %(-x)")
System.print("1 / x = %(x.inverse)")
System.print("x* = %(x.conj)")</syntaxhighlight>
{{out}}
<pre>
x = 1 + 3i
y = 5 + 2i
x + y = 6 + 5i
x - y = -4 + 1i
x * y = -1 + 17i
x / y = 0.37931034482759 + 0.44827586206897i
-x = -1 - 3i
1 / x = 0.1 - 0.3i
x* = 1 - 3i
</pre>
=={{header|XPL0}}==
<
func real CAdd(A, B, C); \Return complex sum of two complex numbers
Line 3,689 ⟶ 5,617:
COut(0, CInv(U,W)); CrLf(0);
COut(0, Conj(U,W)); CrLf(0);
]</
{{out}}
<pre>
4.14 + 2.20i
Line 3,699 ⟶ 5,627:
1.00 - 1.00i
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">rem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
rem CADDI/CADDR addition of complex numbers Z1 + Z2 with Z1 = a1 + b1 *i Z2 = a2 + b2*i
rem CADDI returns imaginary part and CADDR the real part
rem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
export sub caddi( a1 , b1 , a2 , b2)
return (b1 + b2)
end sub
export sub caddr( a1 , b1 , a2 , b2)
return (a1 + a2)
end sub
rem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
rem CDIVI/CDIVR division of complex numbers Z1 / Z2 with Z1 = r + s *i Z2 = t + u*i
rem CDIVI returns imaginary part and CDIVR the real part
rem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
export sub cdivi(r,s,t,u)
return ((s*t- u*r) / (t^2 + u^2))
end sub
export sub cdivr( r , s , t , u)
return ((r*t- s*u) / (t^2 + u^2))
end sub
rem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
rem CMULI/CMULR multiplication of complex numbers Z1 * Z2, with Z1 = r + s *i Z2 = t + u*i
rem CMULI returns imaginary part and CMULR the real part
rem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
export sub cmuli( r , s , t , u)
return (r * u + s * t)
end sub
export sub cmulr( r , s , t , u)
return (r * t - s * u)
end sub
rem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
rem CSUBI/CSUBR subtraction of complex numbers Z1 - Z2 with Z1 = a1 + b1 *i Z2 = a2 + b2*i
rem CSUBI returns imaginary part and CSUBR the real part
rem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
export sub csubi( a1 , b1 , a2 , b2)
return (b1 - b2)
end sub
export sub csubr( a1 , b1 , a2 , b2)
return (a1 - a2)
end sub
if (peek$("library") = "main") then
print "Example: Z1 + Z2 with Z1 = 3 +2i , Z2 = 1-3i: Z1 + Z2 = 4 -1i"
print caddr(3,2,1,-2), "/", caddi(3,2,1,-3) // 4/-1
end if</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang="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)</syntaxhighlight>
{{out}}
<pre>
(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)
</pre>
=={{header|zonnon}}==
<syntaxhighlight lang="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 r
end "+";
operator {public} "-" (a,b: Complex): Complex;
var
r: Complex;
begin
r.re := a.re - b.re;
r.im := a.im - b.im;
return r
end "-";
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 r
end "*";
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 r
end "/";
operator {public} "-" (a: Complex): Complex;
begin
a.im := -1 * a.im;
return a
end "-";
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 c
end "~";
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.
</syntaxhighlight>
{{Out}}
<pre>
( 2,5 ; 4 i)
( ,5 ; 2 i)
(-1,5 ; 4,5 i)
(2,25 ; ,75 i)
( 1,5 ; -3 i)
( ,5 ; -,5 i)
</pre>
=={{header|ZX Spectrum Basic}}==
{{trans|BBC BASIC}}
<syntaxhighlight lang="zxbasic">5 LET complex=2: LET r=1: LET i=2
10 DIM a(complex): LET a(r)=1.0: LET a(i)=1.0
20 DIM b(complex): LET b(r)=PI: LET b(i)=1.2
30 DIM o(complex)
40 REM add
50 LET o(r)=a(r)+b(r)
60 LET o(i)=a(i)+b(i)
70 PRINT "Result of addition is:": GO SUB 1000
80 REM mult
90 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 1000
120 REM neg
130 LET o(r)=-a(r)
140 LET o(i)=-a(i)
150 PRINT "Result of negation is:": GO SUB 1000
160 LET denom=a(r)^2+a(i)^2
170 LET o(r)=a(r)/denom
180 LET o(i)=-a(i)/denom
190 PRINT "Result of inversion is:": GO SUB 1000
200 STOP
1000 IF o(i)>=0 THEN PRINT o(r);" + ";o(i);"i": RETURN
1010 PRINT o(r);" - ";-o(i);"i": RETURN
</syntaxhighlight>
{{out}}
<pre>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</pre>
{{omit from|M4}}
|