Arithmetic/Complex: Difference between revisions

{{trans|Python}}

V z2 = 1.5 + 1.5i

print(z1 + z2)

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

{{libheader|Action! Tool Kit}}

DEFINE R_="+0"

=={{header|Ada}}==

with Ada.Text_IO.Complex_IO;

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

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

Complex is a built-in type in Algol W.

% show some complex arithmetic %

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

=={{header|APL}}==

x←1j1 ⍝assignment

y←5.25j1.5

=={{header|Arturo}}==

b: to :complex @[pi 1.2]

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

=={{header|AWK}}==

contributed by af

function complex(arr, re, im) {

arr["re"] = re

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

real AS DOUBLE

imag AS DOUBLE

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

{{works with|BBC BASIC for Windows}}

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

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

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

{{works with|C89}}

User-defined type:

double real;

double imag;

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

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

{

using System;

}</syntaxhighlight>

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

public struct ComplexNumber

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

#include <complex>

using std::complex;

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

===.NET Complex class===

{{trans|C#}}

$SET ILUSING "System"

$SET ILUSING "System.Numerics"

===Implementation===

class-id Prog.

method-id. Main static.

=={{header|CoffeeScript}}==

# create an immutable Complex type

class Complex

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)

Here are some arithmetic operations on complex numbers:

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

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

BlackBox Component Builder

MODULE Complex;

IMPORT StdLog;

=={{header|D}}==

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

void main() {

=={{header|Dart}}==

class complex {

{{libheader| System.SysUtils}}

{{libheader| System.VarCmplx}}

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

=={{header|Elixir}}==

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

=={{header|Erlang}}==

%% Author: Abhay Jain

end. </syntaxhighlight>

{{out}}

Ans = -1+17i

Ans = -1-3i

=={{header|ERRE}}==

PROGRAM COMPLEX_ARITH

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

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

>a+b

=={{header|Euphoria}}==

type complex(sequence s)

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

C1:

=IMSUM(A1;B1)

</syntaxhighlight>

D1:

=IMPRODUCT(A1;B1)

</syntaxhighlight>

E1:

=IMSUB(0;D1)

</syntaxhighlight>

F1:

=IMDIV(1;E28)

</syntaxhighlight>

G1:

=IMCONJUGATE(C28)

</syntaxhighlight>

E1 will have the negation of D1's value

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

</syntaxhighlight>

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

Entered into an interactive session to show the results:

> open Microsoft.FSharp.Math;;

=={{header|Factor}}==

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

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

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

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"

=={{header|FreeBASIC}}==

Type Complex

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

FreePascal has a complex units. Example of usage:

uses

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

=={{header|Futhark}}==

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

type complex = (f64,f64)

=={{header|GAP}}==

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

i := Sqrt(-1);

=={{header|Go}}==

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

import (

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

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

class ComplexCategory {

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

Number.metaClass.mixin ComplexCategory

=={{header|Hare}}==

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

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

main = do

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

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

<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

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

=={{header|Java}}==

public final double real;

public final double imag;

=={{header|JavaScript}}==

this.r = r;

this.i = i;

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;

test( [1,1]; [0,1] )</syntaxhighlight>

{{Out}}

"x = [1,1]"

"y = [0,1]"

=={{header|Julia}}==

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

julia> z2 = 1.5 + 1.5im

julia> z1 + z2

=={{header|Kotlin}}==

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

=={{header|Lambdatalk}}==

{require lib_complex}

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

(defrecord complex

real

Here are the required functions:

(defun add

(((match-complex real r1 img i1)

Bonus:

(defun conj

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

The functions above are built using the following supporting functions:

(defun new (r i)

(make-complex real r img i))

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

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

print " Adding"

=={{header|Lua}}==

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

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

y := Pi+I*1.2;</syntaxhighlight>

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

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

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 =

=={{header|Maxima}}==

2*%i+5

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

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

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

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

IMPORT InOut;

{{trans|Java}}

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

class Complex

=={{header|Nemerle}}==

using System.Console;

using System.Numerics;

=={{header|Nim}}==

import complex

var a: Complex = (1.0,1.0)

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

Oxford Oberon Compiler

MODULE Complex;

IMPORT Files,Out;

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

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

=={{header|Octave}}==

GNU Octave handles naturally complex numbers:

z2 = 1.5 + 1.5i;

disp(z1 + z2); % 3.0 + 4.5i

=={{header|Oforth}}==

Complex method: re @re ;

Usage :

2 3 Complex new 1.2 >complex + .cr

2 3 Complex new 1.2 >complex * .cr

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)

=={{header|ooRexx}}==

c2 = .complex~new(3, 4)

r = 7

=={{header|OxygenBasic}}==

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

'COMPLEX OPERATIONS

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

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

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

mult(a,b)=a*b;

neg(a)=-a;

{{works with|Extended Pascal}}

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

const

=={{header|Perl}}==

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

my $a = 1 + 1*i;

my $b = 3.14159 + 1.25*i;

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

=={{header|PicoLisp}}==

(de addComplex (A B)

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

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

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

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

a+b =>

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{

=={{header|PowerShell}}==

===Implementation===

class Complex {

[Double]$x

</pre>

===Library===

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

if(0 -le $c.Imaginary) {

=={{header|PureBasic}}==

real.d

imag.d

=={{header|Python}}==

>>> z2 = 1.5 + 1.5j

>>> z1 + z2

{{trans|Octave}}

z2 <- 1.5 + 1.5i

print(z1 + z2) # 3+4.5i

=={{header|Racket}}==

#lang racket

{{works with|Rakudo|2015.12}}

my $b = pi + 1.25i;

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

=={{header|RLaB}}==

>> x = sqrt(-1)

0 + 1i

=={{header|Ruby}}==

# Four ways to write complex numbers:

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

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

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

package object ArithmeticComplex {

Usage example:

import org.rosettacode.ArithmeticComplex._

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

=={{header|Seed7}}==

include "float.s7i";

include "complex.s7i";

=={{header|Sidef}}==

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

=={{header|Slate}}==

a: 1 + 1 i.

b: Pi + 1.2 i.

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

|a b|

a := 1 + 1 i.

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

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

A=1+2i

B=3-5i

{{works with|CSnobol}}

data('complex(r,i)')

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

(* Signature for complex numbers *)

signature COMPLEX = sig

=={{header|Stata}}==

C(2,3)

2 + 3i

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

=={{header|Tcl}}==

{{tcllib|math::complexnumbers}}

namespace import math::complexnumbers::*

=={{header|UNIX Shell}}==

{{works with|ksh93}}

float real=0

float imag=0

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

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

=={{header|VBA}}==

Public Type Complex

re As Double

=={{header|Vlang}}==

fn main() {

a := complex.complex(1, 1)

=={{header|Wortel}}==

{{trans|CoffeeScript}}

&[r i] @: {

^r || r 0

=={{header|Wren}}==

{{libheader|Wren-complex}}

var x = Complex.new(1, 3)

=={{header|XPL0}}==

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

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

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

=={{header|zonnon}}==

module Numbers;

type

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