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

 

{{out}}<pre>

-a=-1.0000⊥-1.0000

</pre>

=={{header|APL}}==

x←1j1 ⍝assignment

y←5.25j1.5

-x ⍝negation

¯1J¯1

 

=={{header|App Inventor}}==

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

{{out}}

 

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

{{out}}

<pre>Result of addition is 4.14159265 + 2.2i

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

& out

$ ("sin$x minus conjugate sin$x =" sin$x+negate$(conjugate$(sin$x)))

{{out}}

<pre>(a+i*b)+(a+i*b) = 2*a+2*i*b

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

 

c = conj(a);

printf("\nconj a="); cprint(c); printf("\n");

 

{{works with|C89}}

User-defined type:

double real;

double imag;

printf("\n-a="); put(neg(a));

printf("\nconj a="); put(conj(a)); printf("\n");

 

{

using System;

}

}

 

public struct ComplexNumber

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

}

 

=={{header|C++}}==

#include <complex>

using std::complex;

// conjugate

std::cout << std::conj(a) << std::endl;

 

=={{header|Clojure}}==

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

(let [m (+ (* r r) (* i i))]

(->Complex (/ r m) (- (/ i m)))))

 

=={{header|COBOL}}==

===.NET Complex class===

{{trans|C#}}

$SET ILUSING "System"

$SET ILUSING "System.Numerics"

end-perform

end method.

 

===Implementation===

class-id Prog.

method-id. Main static.

end operator.

 

 

=={{header|CoffeeScript}}==

# create an immutable Complex type

class Complex

quotient = product.times inverse

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

 

{{out}}

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)

 

 

> (conjugate #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)

 

 

> (imagpart (complex 0 pi))

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE Complex;

IMPORT StdLog;

 

END Complex.

Execute: ^Q Complex.Do<br/>

{{out}}

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

{{out}}

<pre>4.14159+2.2i

 

=={{header|Dart}}==

 

class complex {

 

}

 

=={{header|EchoLisp}}==

Complex numbers are part of the language. No special library is needed.

(define a 42+666i) → a

(define b 1+i) → b

(magnitude b) → 1.4142135623730951 ; = sqrt(2)

(exp (* I PI)) → -1+0i ; Euler = e^(I*PI) = -1

 

=={{header|Erlang}}==

%% Author: Abhay Jain

 

true ->

io:format("Ans = ~p+~pi~n", [A#complex.real, A#complex.img])

{{out}}

Ans = -1+17i

Ans = -1-3i

Ans = 0.1-0.3i

 

=={{header|ERRE}}==

PROGRAM COMPLEX_ARITH

 

PRINT(Z.REAL#;" + ";Z.IMAG#;"i")

END PROGRAM

Note: Adapted from QuickBasic source code

{{out}}

=={{header|Euler Math Toolbox}}==

 

>a=1+4i; b=5-3i;

>a+b

>conj(a)

1-4i

 

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

 

{{out}}

 

C1:

=IMSUM(A1;B1)

 

D1:

=IMPRODUCT(A1;B1)

 

E1:

=IMSUB(0;D1)

 

F1:

=IMDIV(1;E28)

 

G1:

=IMCONJUGATE(C28)

 

E1 will have the negation of D1's value

 

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

 

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

println["1/$a = " + invert[a]]

println["conjugate[$a] = " + conjugate[a]]

 

{{out}}

conjugate[( 3 + 2.5 i )] = ( 3 - 2.5 i )

</pre>

 

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

{{out}}

<pre>

=={{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 i = [0,1] as Complex

Complex(Number r, Number i = 0) { (real, imag) = [r, i] }

Complex(Map that) { (real, imag) = [that.real ?: 0, that.imag ?: 0] }

Complex plus (Complex c) { [real + c.real, imag + c.imag] as Complex }

Complex plus (Number n) { [real + n, imag] as Complex }

Complex minus (Complex c) { [real - c.real, imag - c.imag] as Complex }

Complex minus (Number n) { [real - n, imag] as Complex }

Complex multiply (Complex c) { [real*c.real - imag*c.imag , imag*c.real + real*c.imag] as Complex }

Complex multiply (Number n) { [real*n , imag*n] as Complex }

Complex div (Complex c) { this * c.recip() }

Complex div (Number n) { this * (1/n) }

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

/** the complex conjugate of this complex number. Overloads the bitwise complement (~) operator. */

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

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

// could also use Math.sqrt( (this * (~this)).real )

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

Number abs() { this.abs }

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

Complex getRecip() { (~this) / (ρ**2) }

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

Complex recip() { this.recip }

/** derived polar angle θ (theta) for polar form. Normalized to 0 ≤ θ < 2π. */

Number getTheta() {

/** derived polar angle θ (theta) for polar form. Normalized to 0 ≤ θ < 2π. */

Number getΘ() { this.theta } // this is greek uppercase theta

/** derived polar magnitude ρ (rho) for polar form. */

Number getRho() { this.abs }

/** derived polar magnitude ρ (rho) for polar form. */

Number getΡ() { this.abs } // this is greek uppercase rho, not roman P

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

* converting [ρ, θ] inputs into a [real, imag]-based complex number */

[ρ * Math.cos(θ), ρ * Math.sin(θ)] as Complex

}

/** Creates new complex with same magnitude ρ, but different angle θ */

Complex withTheta(Number θ) { fromPolar(this.rho, θ) }

/** Creates new complex with same magnitude ρ, but different angle θ */

Complex withΘ(Number θ) { fromPolar(this.rho, θ) }

/** Creates new complex with same angle θ, but different magnitude ρ */

Complex withRho(Number ρ) { fromPolar(ρ, this.θ) }

/** Creates new complex with same angle θ, but different magnitude ρ */

Complex withΡ(Number ρ) { fromPolar(ρ, this.θ) } // this is greek uppercase rho, not roman P

static Complex exp(Complex c) { fromPolar(Math.exp(c.real), c.imag) }

static Complex log(Complex c) { [Math.log(c.rho), c.theta] as Complex }

Complex power(Complex c) {

: c == 1 \

? this \

: exp( log(this) * c )

}

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

boolean equals(that) {

that != null && (that instanceof Complex \

: that instanceof Number && [this.real, this.imag] == [that, 0])

}

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

String toString() {

def realPart = "${real}"

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

}

 

The following ''ComplexCategory'' class allows for modification of regular ''Number'' behavior when interacting with ''Complex''.

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 div (Number a, Complex b) { ([a] as Complex) / b }

static Complex power (Number a, Complex b) { ([a] as Complex) ** b }

type == Complex \

: DefaultGroovyMethods.asType(a, type)

}

Notice also that this solution takes liberal advantage of Groovy's full Unicode support, including support for non-English alphabets used in identifiers.

 

Test Program (mixes the ComplexCategory methods into the Number class):

Number.metaClass.mixin ComplexCategory

def ε = 0.000000001 // tolerance (epsilon): acceptable "wrongness" to account for rounding error

println 'Demo 1: functionality as requested'

def a = [5,3] as Complex

def b = [0.5,6] as Complex

println 'b == ' + b

println "a + b == (${a}) + (${b}) == " + (a + b)

println "a * b == (${a}) * (${b}) == " + (a * b)

println "a * 1/a == " + (a * a.recip)

println()

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

def c = 10

println 'a.θ == ' + a.θ

println '~a (conjugate) == ' + ~a

def ρ = 10

def π = Math.PI

def n = 3

def θ = π / n

def fromPolar1 = fromPolar(ρ, θ) // direct polar-to-cartesian conversion

def fromPolar2 = exp(θ.i) * ρ // Euler's equation

println " == 10*0.5 + i*10*√(3/4) == " + fromPolar1

println "ρ*exp(i*θ) == ${ρ}*exp(i*π/${n}) == " + fromPolar2

 

{{out}}

a ** 2 == a * a == 16.000000000000004 + 30.000000000000007i

0.9 ** b == 0.7653514303676113 - 0.5605686291920475i

a.real == 5

a.imag == 3

== 10*0.5 + i*10*√(3/4) == 5.000000000000001 + 8.660254037844386i

ρ*exp(i*θ) == 10*exp(i*π/3) == 5.000000000000001 + 8.660254037844386i</pre>

 

=={{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 $ "Negate: " ++ show (-a)

putStrLn $ "Inverse: " ++ show (recip a)

 

{{out}}

Inverse: 0.2 :+ (-0.4)

Conjugate:1.0 :+ (-2.0)</pre>

 

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

To take full advantage of the overloaded 'complex' procedure,

the other cpxxxx procedures would need to be rewritten or overloaded.

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;

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.

 

 

def imag(z): if (z|type) == "number" then 0 else z[1] end;

x[0] * y[1] + x[1] * y[0]]

end;

 

def negate(x): multiply(-1; x);

;

 

{{Out}}

"x = [1,1]"

"y = [0,1]"

"conj(x): [1,-1]"

"(x/y)*y: [1,1]"

 

=={{header|LFE}}==

 

 

A convenient data structure for a complex number is the record:

(defrecord complex

real

img)

 

Here are the required functions:

 

(defun add

(((match-complex real r1 img i1)

(defun inv (cmplx)

(div (conj cmplx) (modulus cmplx)))

 

Bonus:

 

(defun conj

(((match-complex real r img i))

(new r (* -1 i))))

 

The functions above are built using the following supporting functions:

 

(defun new (r i)

(make-complex real r img i))

(/ (complex-img c3) denom)))))

 

 

Finally, we have some functions for use in the conversion and display of our complex number data structure:

 

(defun ->str

(((match-complex real r img i)) (when (>= i 0))

(defun print (cmplx)

(io:format (++ (->str cmplx) "~n")))

 

Usage is as follows:

 

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

 

print " Adding"

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|Maxima}}==

2*%i+5

 

 

imagpart(z1);

 

=={{header|МК-61/52}}==

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

 

ИПD x^2 + П3 ИПA ИПC * ИПB ИПD *

+ ИП3 / П1 ИПB ИПC * ИПA ИПD *

+ П2 ИП1 С/П ИПB ИПD + П2 ИПA ИПC

+ ИП1 С/П ИПB ИПD - П2 ИПA ИПC -

 

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

 

IMPORT InOut;

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

InOut.WriteLn

{{out}}

<pre>Enter two complex numbers : 5 3 0.5 6

1 / z1 = 0.15 - 0.09 i

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

 

=={{header|Nemerle}}==

using System.Console;

using System.Numerics;

WriteLine(Conjugate(complex2).PrettyPrint());

}

{{out}}

<pre>4.14159 + 2.2i

 

=={{header|Nim}}==

import complex

 

{{out}}

<pre>

=={{header|Oberon-2}}==

Oxford Oberon Compiler

MODULE Complex;

IMPORT Files,Out;

END Complex.

{{out}}

<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 (inv a);

print_complex (neg 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|Oforth}}==

 

 

 

Complex method: inv

| n |

 

Usage :

 

 

{{out}}

(0.307692307692308,-0.461538461538462)

</pre>

 

=={{header|ooRexx}}==

c2 = .complex~new(3, 4)

r = 7

::method hashCode

expose r i

{{out}}

<pre>c1 = 1 + 2i

=={{header|OxygenBasic}}==

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

'COMPLEX OPERATIONS

'=================

z1 = z1*z4

print "Z1 = "+z1.show 'RESULT 2.0, 1.0

 

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

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

mult(a,b)=a*b;

neg(a)=-a;

 

=={{header|Pascal}}==

 

type

 

 

 

 

 

 

begin

 

var

 

 

begin

end.

 

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

 

<pre>

</pre>

 

=={{header|PicoLisp}}==

 

(de addComplex (A B)

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

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

{{out}}

<pre>A = 1.00000+1.00000i

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|Racket}}==

 

#lang racket

 

(/ 1 a) ; reciprocal

(conjugate a) ; conjugation

 

=={{header|REXX}}==

 

Cinv: return Cdiv(1, arg(1))

Cneg: return Cmul(arg(1), -1)

<pre>

addition: (5,3i) + ( .5, 6j) = [5.5,9j]

=={{header|RLaB}}==

 

>> x = sqrt(-1)

0 + 1i

>> isreal(z)

1

 

=={{header|Ruby}}==

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)

 

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|Rust}}==

use num::complex::Complex;

 

println!(" -a = {}", -a);

println!("conj(a) = {}", a.conj());

 

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

[ a + b, # addition

a * b, # multiplication

-a, # negation

a.abs, # abs

b.re, # real

b.im, # imaginary

{{out}}

<pre>4.14159+2.25i

-1-i

0.5-0.5i

3.14159

1.25</pre>

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

 

=={{header|smart BASIC}}==

A=1+2i

B=3-5i

 

' gives output

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

data('complex(r,i)')

 

output = printx( negx(a) ) ', ' printx( negx(b) )

output = printx( invx(a) ) ', ' printx( invx(b) )

 

{{out}}

 

=={{header|Standard ML}}==

(* Signature for complex numbers *)

signature COMPLEX = sig

Complex.print_number(Complex.times i1 i2); (* -5 + 10i *)

Complex.print_number(Complex.invert i1); (* 1/5 - 2i/5 *)

 

=={{header|Tcl}}==

{{tcllib|math::complexnumbers}}

namespace import math::complexnumbers::*

 

puts [tostring [* $a $b]] ;# ==> 1.94159+4.34159i

puts [tostring [pow $a [complex -1 0]]] ;# ==> 0.5-0.4999999999999999i

 

=={{header|TI-83 BASIC}}==

 

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|UNIX Shell}}==

{{works with|ksh93}}

float real=0

float imag=0

Complex_t d=(real=2 imag=1)

d.inverse

 

=={{header|Ursala}}==

c..add or ..csin). Real operands are promoted to complex.

 

v = 9.545e-01-3.305e+00j

 

complex..mul (u,v),

complex..sub (0.,u),

{{out}}

<pre><

3.785e+00-1.969e+00j,

8.066e-02+2.793e-01j></pre>

 

=={{header|Wortel}}==

{{trans|CoffeeScript}}

&[r i] @: {

^r || r 0

"1 / ({b}) = {b.inv.}"

"({!a.mul b}) / ({b}) = {`!.mul b.inv. !a.mul b}"

{{out}}

<pre>(5 + 3i) + (4 - 3i) = 9

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

(29 - 3i) / (4 - 3i) = 5 + 3i</pre>

 

=={{header|XPL0}}==

 

func real CAdd(A, B, C); \Return complex sum of two complex numbers

COut(0, CInv(U,W)); CrLf(0);

COut(0, Conj(U,W)); CrLf(0);

 

{{out}}

1.00 - 1.00i

</pre>

 

{{omit from|M4}}