Arithmetic/Complex: Difference between revisions

{{task|Arithmetic operations}}

 

 

 

=={{header|Ada}}==

with Ada.Text_IO.Complex_IO;

 

New_Line;

-- Conjugation

 

=={{header|ALGOL 68}}==

{{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)$;

);

compl operations

a=1.00000⊥1.00000

b=3.14159⊥1.20000

-a=-1.0000⊥-1.0000

</pre>

=={{header|APL}}==

x←1j1 ⍝assignment

y←5.25j1.5

-x ⍝negation

¯1J¯1

 

=={{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)

NumPut( Cre(A)/d,C,0,"double")

NumPut(-Cim(A)/d,C,8,"double")

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

real AS DOUBLE

imag AS DOUBLE

END TYPE

DECLARE SUB mult (a AS complex, b AS complex, c AS complex)

DECLARE SUB neg (a AS complex, b AS complex)

CLS

DIM x AS complex

y.real = 2

y.imag = 2

CALL mult(x, y, z)

CALL neg(x, z)

 

c.real = a.real + b.real

c.imag = a.imag + b.imag

b.real = -a.real

b.imag = -a.imag

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

DIM a{} = Complex{} : a.r = 1.0 : a.i = 1.0

DEF FNcomplexshow(src{})

IF src.i >= 0 THEN = STR$(src.r) + " + " +STR$(src.i) + "i"

<pre>Result of addition is 4.14159265 + 2.2i

Result of multiplication is 1.94159265 + 4.34159265i

Result of negation is -1 - 1i

Result of inversion is 0.5 - 0.5i</pre>

 

=={{header|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++]].) [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]

 

void cprint(double complex c)

// negation

c = -a;

 

{{works with|C89}}

User-defined type:

double real;

double imag;

}

 

Complex inv(Complex a){

Complex ans;

double denom = a.real * a.real + a.imag * a.imag;

ans.imag = -a.imag / denom;

return ans;

Complex ans;

ans.real = -a.real;

ans.imag = -a.imag;

return ans;

void put(Complex c)

{

}

 

printf("\na*b="); put(mult(a,b));

printf("\n1/a="); put(inv(a));

 

 

 

public struct ComplexNumber

Console.WriteLine(ComplexMath.Power(j, 0) == 1.0);

}

 

=={{header|CoffeeScript}}==

# create an immutable Complex type

class Complex

quotient = product.times inverse

console.log "(#{product}) / (#{b}) = #{quotient}"

 

> coffee complex.coffee

(5 + 3i) + (4 - 3i) = 9

1 / (4 - 3i) = 0.16 + 0.12i

(29 - 3i) / (4 - 3i) = 5 + 3i

 

=={{header|Common Lisp}}==

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)

 

Here are some arithmetic operations on complex numbers:

 

#C(1 1)

 

 

> (/ #c(0 2))

 

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)

 

 

> (imagpart (complex 0 pi))

 

=={{header|D}}==

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

 

void main() {

writeln(1.0 / x); // inversion

writeln(-x); // negation

<pre>4.14159+2.2i

1.94159+4.34159i

0.5-0.5i

-1-1i</pre>

 

=={{header|Euphoria}}==

type complex(sequence s)

return length(s) = 2 and atom(s[REAL]) and atom(s[IMAG])

printf(1,"a*b = %s\n",{scomplex(mult(a,b))})

printf(1,"1/a = %s\n",{scomplex(inv(a))})

 

<pre>a = 1+i

b = 3.14159+1.2i

1/a = 0.5-0.5i

-a = -1-i</pre>

 

=={{header|F Sharp|F#}}==

Entered into an interactive session to show the results:

> open Microsoft.FSharp.Math;;

 

i = -1.0;

r = -1.0;}

 

=={{header|Factor}}==

 

C{ 1 2 } C{ 0.9 -2.78 } {

C{ 1 2 } {

[ neg . ] ! negation

[ conjugate . ] ! complex conjugate

[ sin . ] ! sine

[ log . ] ! natural logarithm

[ sqrt . ] ! square root

 

=={{header|Forth}}==

{{libheader|Forth Scientific Library}}

 

zvariable x

x z@ y z@ z+ z.

x z@ y z@ z* z.

1+0i x z@ z/ 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

aneg = -a

ainv = 1.0 / a

 

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"

abpow = a ** b

areal = real(a) ! Real part

newc = cmplx(x,y) ! Creating a complex on the fly from two reals intrinsically

! (initializer only works in declarations)

! useful for FFT calculations, among other things

unit_circle = exp(2*i*pi/n * (/ (j, j=0, n-1) /) )

=={{header|GAP}}==

# E(n) is an nth primitive root of 1

i := Sqrt(-1);

# true

Sqrt(-3) in Cyclotomics;

 

=={{header|Go}}==

Go has complex numbers built in, with the complex conjugate in the standard library.

 

import (

fmt.Println("1 / a: ", 1/a)

fmt.Println("a̅: ", cmplx.Conj(a))

<pre>

a: (1+1i)

=={{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

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 }

Complex bitwiseNegate () { [real, -imag] as Complex }

/** the magnitude of this complex number. */

Number getTheta() {

}

/** Runs Euler's polar-to-Cartesian complex conversion,

}

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) {

: c == 1 \

? this \

: exp( log(this) * c )

}

Complex power(Number n) { this ** ([n, 0] as Complex) }

}

int hashCode() { [real, imag].hashCode() }

String toString() {

def realPart = "${real}"

: realPart + (imag > 0 ? " + " : " - ") + imagPart

}

 

 

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)

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

 

<pre>Demo 1: functionality as requested

a == 5 + 3i

a * b == (5 + 3i) * (0.5 + 6i) == -15.5 + 31.5i

-a == -(5 + 3i) == -5 - 3i

 

Demo 2: other functionality not requested, but important for completeness

a - b == (5 + 3i) - (0.5 + 6i) == 4.5 - 3i

a.real == 5

a.imag == 3

a.rho == 5.830951894845301

a.theta == 0.5404195002705842

 

 

=={{header|Haskell}}==

have ''Complex Integer'' for the Gaussian Integers, ''Complex Float'', ''Complex Double'', etc. The operations are just the usual overloaded numeric operations.

 

 

main = do

putStrLn $ "Divide: " ++ show (a / b)

putStrLn $ "Negate: " ++ show (-a)

 

Add: 5.0 :+ 2.0

Subtract: (-3.0) :+ 2.0

Divide: 0.25 :+ 0.5

Negate: (-1.0) :+ (-2.0)

 

=={{header|Icon}} and {{header|Unicon}}==

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

 

SetupComplex()

write("abs(a) := ", cpxabs(a))

write("neg(1) := ", cpxstr(cpxneg(1)))

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.

link complex # for complex number support

 

denom := z.rpart ^ 2 + z.ipart ^ 2

return complex(z.rpart / denom, z.ipart / denom)

 

<pre>#complexdemo.exe

 

neg(1) := (-1.0+0.0i)</pre>

 

 

=={{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

4.14159j2.2

1.94159j4.34159

0.5j_0.5

 

=={{header|Java}}==

 

 

 

 

 

 

 

 

=={{header|JavaScript}}==

this.r = r;

this.i = i;

var denom = Math.pow(z.r,2) + Math.pow(z.i,2);

return new Complex(z.r/denom, -1*z.i/denom);

}

 

 

Complex.prototype.toString = function() {

: "" ) + ( 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) )

 

=={{header|Liberty BASIC}}==

 

call cprint cadd$( complex$( 1, 1), complex$( 3.14159265, 1.2))

call cprint cmulti$( complex$( 1, 1), complex$( 3.14159265, 1.2))

call cprint cinv$( complex$( 1, 1))

call cprint cneg$( complex$( 1, 1))

 

D =ar^2 +ai^2

cinv$ =complex$( ar /D , 0 -ai /D )

 

=={{header|Lua}}==

 

--defines addition, subtraction, negation, multiplication, division, conjugation, norms, and a conversion to strgs.

print("|" .. i .. "| = " .. math.sqrt(i.norm))

print(i .. "* = " .. i.conj)

 

=={{header|Maple}}==

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

 

 

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);

 

Other than that, the task merely asks for

 

x*y;

-x;

 

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

 

y^4 => -527 - 336 I

x^y => (1 + 2 I)^(3 + 4 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

Haversine InverseHaversine

Factorial Gamma PolyGamma LogGamma

and many many more. The documentation states:

 

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 =

ans =

 

 

=={{header|Modula-2}}==

 

IMPORT InOut;

NegComplex (z[0], z[2]); ShowComplex (" - z1", z[2]);

InOut.WriteLn

z1 = 5.00 + 3.00 i

z2 = 0.50 + 6.00 i

- z1 = -5.00 - 3.00 i</pre>

 

 

=={{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 =

print_complex (mul a b);

print_complex (inv 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

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

disp( imag(z1) ); % 3

disp( real(z2) ); % 1.5

 

=={{header|PARI/GP}}==

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

mult(a,b)=a*b;

neg(a)=-a;

 

=={{header|Pascal}}==

 

type

 

 

 

 

 

 

 

begin

 

 

 

 

=={{header|Perl}}==

The <code>Math::Complex</code> module implements complex arithmetic.

my $a = 1 + 1*i;

my $b = 3.14159 + 1.25*i;

-$a, # negation

1 / $a, # multiplicative inverse

 

 

=={{header|PicoLisp}}==

 

(de addComplex (A B)

(prinl "A*B = " (fmtComplex (mulComplex A B)))

(prinl "1/A = " (fmtComplex (invComplex A)))

<pre>A = 1.00000+1.00000i

B = 3.14159+1.20000i

1/A = 0.50000-0.50000i

-A = -1.00000-1.00000i</pre>

 

=={{header|Pop11}}==

'1 -: 3' is '1 - 3i' in mathematical notation.

 

a+b =>

a*b =>

a-a =>

a/b =>

=={{header|PostScript}}==

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

%Adding two complex numbers

/addcomp{

}def

 

 

=={{header|PureBasic}}==

real.d

imag.d

*c=Neg_Complex(a): ShowAndFree("-a", *c)

Print(#CRLF$+"Press ENTER to exit"):Input()

 

=={{header|Python}}==

 

>>> z2 = 1.5 + 1.5j

>>> z1 + z2

>>> z1.imag

3.0

 

=={{header|R}}==

{{trans|Octave}}

 

z2 <- 1.5 + 1.5i

print(z1 + z2) # 3+4.5i

print(exp(z1)) # -4.436839+0.632456i

print(Re(z1)) # 1.5

 

=={{header|RLaB}}==

 

>> x = sqrt(-1)

0 + 1i

>> isreal(z)

1

 

a = Complex(1, 1) # 1. call Kernel#Complex

i = Complex::I # 2. use Complex::I

b = 3.14159 + 1.25 * i

 

# Operations:

puts 1.quo a # multiplicative inverse

puts a.conjugate # 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

 

=={{header|Scala}}==

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

 

 

package object ArithmeticComplex {

def fromPolar(rho:Double, theta:Double) = Complex(rho*math.cos(theta), rho*math.sin(theta))

}

 

Usage example:

 

import org.rosettacode.ArithmeticComplex._

 

scala> -res6

res7: org.rosettacode.ArithmeticComplex.Complex = -0.2 + 0.4i

 

=={{header|Scheme}}==

* 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)

 

(define c (* a b))

(define c (/ 1 a))

 

=={{header|Seed7}}==

 

include "float.s7i";

include "complex.s7i";

# negation

writeln("-a=" <& -a digits 5);

 

=={{header|Slate}}==

 

a: 1 + 1 i.

b: Pi + 1.2 i.

print: a abs.

print: a negated.

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

|a b|

a := 1 + 1 i.

a real displayNl.

a imaginary displayNl.