Arithmetic/Complex: Difference between revisions

{{trans|Python}}

 

V z2 = 1.5 + 1.5i

print(z1 + z2)

print(z1 ^ z2)

print(z1.real)

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

DEFINE R_="+0"

ComplexConj(y,res)

PrintComplexXY(y,res," conj")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Complex.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Text_IO.Complex_IO;

 

Put("Conjugate(-A) = ");

C := Conjugate (C); Put(C);

 

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

=={{header|ALGOL W}}==

Complex is a built-in type in Algol W.

% show some complex arithmetic %

% returns c + d, using the builtin complex + operator %

write( "1/c : ", cInv( c ) );

write( "conj c : ", cConj( c ) )

{{out}}

<pre>

 

=={{header|APL}}==

x←1j1 ⍝assignment

y←5.25j1.5

-x ⍝negation

¯1J¯1

 

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

=={{header|Arturo}}==

 

b: to :complex @[pi 1.2]

 

print ["1 / a:" 1 / a]

print ["neg a:" neg a]

 

{{out}}

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

contributed by af

function complex(arr, re, im) {

arr["re"] = re

mult(i, i, i)

printComplex(i)

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

real AS DOUBLE

imag AS DOUBLE

c.imag = a.imag - b.imag

END SUB

{{out}}

<pre>Siendo x = 1+ 3i

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

{{libheader| System.SysUtils}}

{{libheader| System.VarCmplx}}

program Arithmetic_Complex;

 

 

Readln;

{{out}}

<pre>(5 + 3i) + (0,5 + 6i) = 5,5 + 9i

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

import Kernel, except: [abs: 1, div: 2]

end

 

 

{{out}}

 

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

[ log . ] ! natural logarithm

[ sqrt . ] ! square root

 

=={{header|Forth}}==

{{libheader|Forth Scientific Library}}

Historically, there was no standard syntax or mechanism for complex numbers and several implementations suitable for different uses were provided. However later a wordset ''was'' standardised as "Algorithm #60".

S" complex.fs" REQUIRED

 

1e 0e zconstant 1+0i

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"

! useful for FFT calculations, among other things

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

 

=={{header|FreeBASIC}}==

 

Type Complex

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Free Pascal}}==

FreePascal has a complex units. Example of usage:

 

uses

writeln ('conj(5 + i3): ', acong.re:3:1, ' + i', acong.im:3:1);

end.

 

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

=={{header|Futhark}}==

{{incorrect|Futhark|Futhark's syntax has changed, so "fun" should be "let"}}

type complex = (f64,f64)

 

else if o == 3 then complexNeg a

else complexConj a

 

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

 

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

<tt>complex</tt> (and <tt>dcomplex</tt> for double-precision) is a built-in data type in IDL:

 

y=complex(!pi,1.2)

print,x+y

( -1.00000, -1.00000)

print,1/x

 

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

+x NB. (complex) conjugation

1j_1

 

=={{header|Java}}==

public final double real;

public final double imag;

System.out.println(a.conj());

}

 

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

;

 

{{Out}}

"x = [1,1]"

"y = [0,1]"

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

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

 

=={{header|Julia}}==

Julia has built-in support for complex arithmetic with arbitrary real types.

julia> z2 = 1.5 + 1.5im

julia> z1 + z2

1.5

julia> imag(z1)

 

=={{header|Kotlin}}==

operator fun plus(other: Complex) = Complex(real + other.real, imag + other.imag)

 

println("1 / x = ${x.inv()}")

println("x* = ${x.conj()}")

 

{{out}}

 

=={{header|Lambdatalk}}==

{require lib_complex}

 

{C.mul {z1} {z2}} -> (0 3)

{C.div {z1} {z2}} -> (0.6666666666666667 0)

 

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

 

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

 

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

{{trans|Java}}

This is a translation of the Java version, but it uses operator redefinition where possible.

 

class Complex

println a.inv()

println a * b

 

=={{header|Nemerle}}==

using System.Console;

using System.Numerics;

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

}

{{out}}

<pre>4.14159 + 2.2i

 

=={{header|Nim}}==

import complex

var a: Complex = (1.0,1.0)

echo("-a : " & $(-a))

 

{{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: re @re ;

 

Integer method: >complex self 0 Complex new ;

 

Usage :

 

2 3 Complex new 1.2 >complex + .cr

2 3 Complex new 1.2 >complex * .cr

 

{{out}}

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

 

(define A 0+1i) ; manually entered numbers

(define B 1+0i)

(print "imaginary part of " C " is " (cdr C))

; <== imaginary part of 2/7-3i is -3

 

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

{{works with|Extended Pascal}}

The simple data type <tt>complex</tt> is part of Extended Pascal, ISO standard 10206.

 

const

writeLn(' inverse(', asString(z), ') = ', asString(inverse(z)));

writeLn(' conjugation(', asString(y), ') = ', asString(conjugation(y)));

{{out}}

<pre>(-3.00, 2.00) + ( 1.00, 4.00) = (-2.00, 6.00)

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

{{out}}

<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

 

=={{header|PL/I}}==

/* In this example, the variables are floating-pint. */

/* For integer variables, change 'float' to 'fixed binary' */

 

/* As well, trigonometric functions may be used with complex */

 

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

===Implementation===

class Complex {

[Double]$x

"1/`$m: $([complex]::show($m.inverse()))"

"conjugate `$m: $([complex]::show($m.conjugate()))"

<b>Output:</b>

<pre>

</pre>

===Library===

function show([System.Numerics.Complex]$c) {

if(0 -le $c.Imaginary) {

"1/`$m: $(show ([System.Numerics.Complex]::Reciprocal($m)))"

"conjugate `$m: $(show ([System.Numerics.Complex]::Conjugate($m)))"

<b>Output:</b>

<pre>

 

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

{{works with|Rakudo|2015.12}}

 

my $b = pi + 1.25i;

 

.say for $a + $b, $a * $b, -$a, 1 / $a, $a.conj;

{{out}} (precision varies with different implementations):

<pre>

=={{header|REXX}}==

The REXX language has no complex type numbers, but most complex arithmetic functions can easily be written.

x = '(5,3i)' /*define X ─── can use I i J or j */

y = "( .5, 6j)" /*define Y " " " " " " " */

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

'''output'''

<pre>

=={{header|RLaB}}==

 

>> x = sqrt(-1)

0 + 1i

>> isreal(z)

1

 

=={{header|Ruby}}==

# Four ways to write complex numbers:

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

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

var b = 3.14159:1.25 # Complex(3.14159, 1.25)

b.re, # real

b.im, # imaginary

{{out}}

<pre>4.14159+2.25i

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

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

|a b|

a := 1 + 1i.

Transcript show:'a2*b2 => '; showCR:(a2 * b2).

Transcript show:'a2/b2 => '; showCR:(a2 / b2).

{{out}}

<pre>a => (1+1i)

<b>Original author unknown {:o(</b>

 

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

 

C(2,3)

2 + 3i

1.28247468 + .982793723i

 

 

=={{header|Swift}}==

Use a struct to create a complex number type in Swift. Math Operations can be added using operator overloading

 

public struct Complex {

}

 

 

Make the Complex Number struct printable and easier to debug by adding making it conform to CustomStringConvertible

 

 

extension Complex : CustomStringConvertible {

}

 

 

Explicitly support subtraction and division

 

public func - (left:Complex, right:Complex) -> Complex {

return left + -right

return Complex(real: num.real/den.real, imaginary: num.imaginary/den.real)

}

 

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

 

=={{header|VBA}}==

Public Type Complex

re As Double

Debug.Print "Sqrt(a) = " & CPrint(c)

End Sub

{{out}}

<pre>

Abs(a) = 3.35410196624968

Sqrt(a) = 1.55789954205168+0.962834868045836i

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

=={{header|Wren}}==

{{libheader|Wren-complex}}

 

var x = Complex.new(1, 3)

System.print("-x = %(-x)")

System.print("1 / x = %(x.inverse)")

 

{{out}}

 

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

 

=={{header|Yabasic}}==

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

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

 

=={{header|zkl}}==

(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(1,0) / GSL.Z(1,1)).println(); // (0.50-0.50i) // inversion

(-GSL.Z(3,4)).println(); // (-3.00-4.00i)

{{out}}

<pre>

 

=={{header|zonnon}}==

module Numbers;

type

Writeln(~b);

end Main.

{{Out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|BBC BASIC}}

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

1000 IF o(i)>=0 THEN PRINT o(r);" + ";o(i);"i": RETURN

1010 PRINT o(r);" - ";-o(i);"i": RETURN

{{out}}

<pre>Result of addition is: