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>

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

=={{header|C sharp|C#}}==

{{works with|C sharp|C#|4.0}}

{

using System;

}

}

{{works with|C sharp|C#|1.2}}

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

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

<lang>

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

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

}

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

class ComplexCategory {

: 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

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

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

{{out}}

=={{header|Hare}}==

use math::complex::{c128,addc128,mulc128,divc128,negc128,conjc128};

let (re, im) = conjc128(x);

fmt::printfln("{} + {}i", re, im)!;

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

{{improve|Unicon|This could be better implemented as an object i n Unicon. Note, however, that Unicon doesn't allow for operator overloading at the current time.}}

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

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

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

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

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