2 views

Uploaded by Quang Hoang

Complex numbers are a useful piece of mathematical apparatus that play a critical role in understanding many applications such as quantum computation. This note summarises some key properties as well as some systems and packages that support programming with complex numbers. We discuss complex number support in Fortran, Python and D as well as library and package support in other languages such as C/C++, Java and Ruby.

- Java mock tests for SCJP
- PraList C++
- IGate Placement Paper
- B.E & B.Tech. Syllabs for Information Technology 3 Semester
- csc111-tutorial07_1
- Java Programming Concepts
- C
- Summer Practice Ias 13 En
- rpc
- Multiple Choice Questions c Language
- Complex Numbers
- Rev Chapter 4 Complex Numbers
- theory of equation
- Mcq 8
- ch03
- Disadvantages in C Language
- apr11certsdreport
- Assignment 06
- Overview dari Bahasa C
- Function Point Specialist

You are on page 1of 13

discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/267386724

Scientists

Article

CITATIONS READS

0 1,633

2 authors:

University of Hull Massey University

358 PUBLICATIONS 2,446 CITATIONS 49 PUBLICATIONS 394 CITATIONS

Some of the authors of this publication are also working on these related projects:

All content following this page was uploaded by Ken Hawick on 27 January 2015.

Technical Report CSTN-048

K.A. Hawick and D.P. Playne

Institute of Information and Mathematical Sciences

Massey University Albany

North Shore 102-904, Auckland, New Zealand

Email: k.a.hawick@massey.ac.nz and daniel.playne@gmail.com

Tel: +64 9 414 0800 Fax: +64 9 441 8181

July 2008

Abstract

Complex numbers are a useful piece of mathematical apparatus that play a critical role in understand-

ing many applications such as quantum computation. This note summarises some key properties as well

as some systems and packages that support programming with complex numbers. We discuss complex

number support in Fortran, Python and D as well as library and package support in other languages

such as C/C++, Java and Ruby.

Keywords: complex numbers; numerical precision; Java; C++; D; FORTRAN; Ruby; Python

1 Complex Numbers

Complex numbers consist of a pair of ordinary Real numbers. Sometimes written as c = (a, b) or z = (x, y) :

x, y R, where a or x is the real part - written Re c or Re z and b or y is the imaginary part, written

Im c or Im z. The use of the word imaginary is historical and perhaps misleading. There is nothing

mystical or weird about complex numbers and the so-called imaginary part is just an ordinary real number

but with a specific contextual meaning. The two ordinary numbers that make up the ordered pair that is a

complex number are often used to denote some entity that has a magnitude and a phase or angle. This is

shown in figure 1.

The pair of numbers specifies a vector in two-dimensional space and is shown drawn on the conventional

Cartesian x-y axes. We can think of a complex number as having its real part represented horizontally on the

conventional real number line taking vales , + and the imaginary part represented vertically and also

taking on , + values. We can also represent the complex number vector using a length (or magnitude)

drawn as r and an angle - drawn as . We often use lower case Greek letters such as theta or phi for

angles.

Pythagoras tells us what the magnitude or length r of the vector is and elementary trigonometry tells us the

1

y

b c = (a,b)

r

angle

x

a

Figure 1: A Complex number c = (a, b) drawn as a vector on conventional Cartesian x-y axes.

angle :

a = Re c (1)

b = Im c (2)

p

r = |c| = abs c = (a2 + b2 ) (3)

a = r cos (4)

b = r sin (5)

b

= arg c = arctan (6)

a

We can use the notion of the square root of 1 denoted as i : i2 1 (or sometimes j in engineering texts)

to exploit the algebra of complex numbers, that will let us use them more effectively.

We represent c = a + ib and use various algebraic properties including:

We need to define +, , operations for complex numbers. Sensible definitions all arise from the master

equation 7:

2

c3 = c1 c2 = (a1 + ib1 )(a2 + ib2 ) = (a1 a2 +i2 b1 b2 ) + i(a1 b2 + b1 a2 )

= (a1 a2 b1 b2 ) + i(a1 b2 + b1 a2 ) = a3 + ib3 (8)

c4 = c1 + c2 = a1 + ib1 + a2 + ib2 = (a1 + a2 ) + i(b1 + b2 ) = a4 + ib4 (9)

It is useful to define the complex conjugation operation that changes the sign of the imaginary part so that

c = a + ib : c a ib = rei . This implies various other useful relations:

1

Re c = (c + c ) = a (10)

2

1

Im c = (c c ) = b (11)

2i

2

|c| = cc = norm c (12)

2iarg c c

e = e2i = (13)

c

(c1 c1 ) = c1 c2 (14)

|c1 c2 | = |c1 | . |c2 | (15)

|c1 + c2 | <= |c1 | + |c2 | (16)

c c a ib

c1 =

= 2 = 2 (17)

cc |c| a + b2

n

rei = rn ein (19)

1 1

rei n = r n ei n (20)

The angle is periodic - a complete rotation of 360 degrees or 2 radians leaves the trigonometrical functions

unchanged, so that:

1 1 1 +2

rei n = r n ei n = r n ei n = . . . (22)

1 n1 1 +2k

n

c = c n = rei = r n ei n , k = 0, 1, 2, . . . , n (23)

Various programming languages and systems support complex numbers directly but in some languages a

separate package or module must be used to enable their use.

In summary:

3

Language Mechanism Data type

C/C++ include <complex.h> complex t

Fortran built-in COMPLEX

D built-in cdouble

Python built-in complex

Ruby require complex complex

In C++ the package complex.h provides a mechanism and library functions based on template classes.

We have:

real, imag returning a real

functions: abs, arg and norm returning a real

functions: conj and polar(r, theta) returning a complex

cos, cosh, sin, sinh, tan, tanh, exp, log, log10, pow, sqrt

the usual operators : +, , , / are all defined as well as the C style operators: + =, =, ... etc.

C++ stream insertion and extraction operators.

Use of these functions is illustrated in the C++ code segment below. The package defines a template class

for complex - it is convenient in this present age of 64 bit processor architectures to decide to use complex

numbers that consist of a pair of doubles. A double is likely to be a 64 bit floating point number on many

systems, although note that the language standard does not mandate this. It is convenient to use the modern

name convention for a type definition and define the data type complex t accordingly.

The code segment in figure 2 will produce output like:

(1,0) = 1 + i. 0

(2,-2) = 2 + i. -2

(2,-2) = 2 + i. -2 = 2.82843 e^ i -0.785398

(0.25,0.25) = 0.25 + i. 0.25 = 0.353553 e^ i 0.785398

Note that 0.785398 corresponds to 45 degrees, and that 2.82843 is approximately 2 2.

The JavaT M programming language does not have the in-built capability to work with complex numbers.

To solve this problem we must define our own class (Complex) which will allow us to to perform complex

arithmetic. The class Complex stores the real and imaginary values of the complex number and provides

a number of methods to allow us to work with these Complex objects. The methods (similar to the C++

methods) that should be provided are:

4

#include <i o s t r e a m >

#include <complex>

using namespace s t d ;

typedef complex<double> c o m p l e x t ;

complex t c1 , c2 , c3 , c4 ;

double a1 , a2 , a3 , a4 , b1 , b2 , b3 , b4 ;

double r3 , r4 , t h e t a 3 , t h e t a 4 ;

a1 = 1 . 0 ;

b1 = 0 . 0 ;

a2 = 2 . 0 ;

b2 = 2.0;

c1 = c o m p l e x t ( a1 , b1 ) ;

c2 = c o m p l e x t ( a2 , b2 ) ;

c o u t << c2 << = << a2 << +i . << b2 << e n d l ;

c3 = c1 c2 ;

a3 = r e a l ( c3 ) ;

b3 = imag ( c3 ) ;

r 3 = abs ( c3 ) ;

t h e t a 3 = a r g ( c3 ) ;

<< r 3 << e i << t h e t a 3 << e n d l ;

c4 = c1 / c2 ;

a4 = r e a l ( c4 ) ;

b4 = imag ( c4 ) ;

r 4 = abs ( c4 ) ;

t h e t a 4 = a r g ( c4 ) ;

c o u t << c4 << = << a4 << +i . << b4 << = << r 4 << e i << t h e t a 4 << e n d l ;

exit (1);

}

Figure 2: C++ Code Example showing use of typical complex t data type from complex.h.

5

re, im fields, accessing a real (double)

functions: abs phase returning a real

functions: conjugate reciprocal returning a Complex

functions: log exp sqrt returning a Complex

functions: cos sin tan acos asin atan returning a Complex

functions: cosh sinh tanh acosh asinh atanh returning a Complex

functions: plus minus times divides returning a Complex

These functions will allow us to perform arithmetic and use Complex numbers in our calculations. The

basic arithmetic +-*/ for our Complex class must be performed by methods such as plus(Complex) and

minus(Complex) due to the fact that JavaT M does not provide us with any way to overload operators. The

signature for our Complex class is shown in figure 3.

public c l a s s Complex {

private double r e ;

private double im ;

public S t r i n g t o S t r i n g ( ) ;

public double r e ( ) ;

public double im ( ) ;

public double phase ( ) ;

public Complex minus ( Complex number ) ;

...

}

One interesting dilemma this style causes is the order in which the expressions are evaluated. c1.plus(c2) quite

clearly represents c1+c2 and c1.minus(c2) should mean c1c2. The order of multiplication is not important

however it is vital for division; it is not entirely clear whether c1.divides(c2) should represent c1 c2

c2 or c1 . For

this reason it was decided that it a better naming convention would be to have the methods times(Complex)

and over(Complex). These names leave no ambiguity in the meaning of equations. c1.over(c2) quite clearly

represents c1

c2 .

Since JavaT M lacks the operator overloading features that are available in C++ we end up with a complex

arithmetic capability that is much more complicated to construct and less directly related to the normal

mathematics syntax than we would be able to attain with a truly built in type. For example the relatively

simple equation c1 = c2/c3 + c4/c5 must be written in the form c1 = c2.over(c3).plus(c4.over(c5)). This

can make writing more complex equation extremely tricky and error prone, however there is a possible

alternative. Although JavaT M does not support operator overloading there is a preprocessor available called

JFront [1] which can provide similar functionality. JFront processes the JavaT M code before it is compiled

into JavaT M byte code and replaces defined operators with standard JavaT M code. For example, the +

operator can be defined by:

6

public c l a s s Complex {

...

Complex o p e r a t o r +(Complex c2 ) {

Complex r e s u l t = new Complex ( ) ;

r e s u l t . r e = t h i s . r e + c2 . r e ;

r e s u l t . im = t h i s . im + c2 . im ;

return r e s u l t ;

}

...

}

c1 = c2 + c3

Before the code is sent to JavaT M , JFront will analyse the code to find the operators defined in each class.

After this step JFront will have changed the Complex class code into:

public c l a s s Complex {

...

Complex o p e r a t o r p l u s ( Complex c2 ) {

Complex r e s u l t = new Complex ( ) ;

r e s u l t . r e = t h i s . r e + c2 . r e ;

r e s u l t . im = t h i s . im + c2 . im ;

return r e s u l t ;

}

...

}

After the class operators have been detected and changed, it will look for the usage of these operators within

the rest of the program and replace them with the appropriate method calls. The example equation will be

replaced by:

c1 = c2.operatorplus(c3)

This effectively automates the process of converting the equation in mathematical notation into the JavaT M

code. JFront provides a simple way of easily expressing Complex arithmetic in the JavaT M programming

language.

Many scientists may have first used complex numbers in programs using Fortran [2]. Fortran has supported

a built in COMPLEX data type consisting of a pair of single precision floating point numbers since its early

language standards. No special compiler directives or include packages are required to use complex numbers

and perform complex arithmetic within Fortran.

Along with support for basic complex number arithmetic, Fortran also supports built in generic functions

for ABS, EXP, LOG, SQRT, SIN, COS, TAN and so forth. The precision of the Fortran complex numbers can be

improved within most modern Fortran compilers by the use of a mechanism such as KIND to specify different

precisions and it is possible to have a double precision (64 bit) complex number type. While there is much to

be said for the orthogonality of COMPLEX with the other types in Fortrans, it is likely that newer programming

projects will use languages like D and its complex number facilities.

7

PROGRAM MYPROG

COMPLEX A, B, C

A = COMPLX( 1 2 3 4 . 0 , 5 6 7 8 . 0 )

READ( 5 , ) B

C = A B

WRITE( 6 , 1 0 0 0 ) C

1000 FORMAT( 1H0 , C IS : , F9 . 4 , + i , F9 . 4 )

C Make C e q u a l to i t s complex c o n j u g a t e :

C = CONJG(C)

WRITE( 6 , ) Real part of C i s : , REAL(C)

STOP

END

6 Complex Numbers in D

The D programming language [3] supports complex numbers as full inbuilt language types. The cdouble

type implements a a complex number as a pair of 64-bit doubles - one each for the real and imaginary parts.

The D language also supports real and creal that are the native machine floating point types. On a MacPro

workstation using Intel Xeon processors the real corresponds to an 80 bit floating point representation which

can be exploited for extra precision, although the IEEE portable 64 bit double and cdouble may be the

normal programmer choices.

The code in figure 5 produces the following output using creal:

2+1i

true

2

2

z 1.41421356237309505+1.41421356237309505i

abs 2

conj 1.41421356237309505+-1.41421356237309505i

norm 4

2

1.38629436111989062

54.5981500331442391

2+1i

true

2

2

z 1.41421356237309515+1.41421356237309515i

abs 2.00000000000000014

8

import s t d . s t d i o ;

import s t d . math ;

r e a l norm ( c r e a l z ) {

return z . r e z . r e + z . im z . im ;

}

c r e a l z1 , z2 ;

i r e a l i1 = 2.0 i ;

z1 = 2 . 0 + 1 . 0 i ;

w r i t e f l n ( %s , z1 ) ;

z1 = z1 . r e + 1 . 5 i ;

z1 = z1 . r e + i 1 ;

z2 = z1 . r e + z1 . im 1 i ;

w r i t e f l n ( %s , z1 == z2 ) ;

w r i t e f l n ( %s , z1 . r e ) ;

w r i t e f l n ( %s , z1 . im ) ;

z1 /= 2 . 0 ;

z1 = 2 . 0 ;

z1 = s q r t ( z1 . r e ) + s q r t ( z1 . im ) 1 i ;

writefln (z %.18 s , z1 );

w r i t e f l n ( c o n j %.18 s , c o n j ( z1 ) ) ;

w r i t e f l n ( norm %.18 s , norm ( z1 ) ) ;

w r i t e f l n ( %.18 s , s q r t ( norm ( z1 ) ) ) ;

w r i t e f l n ( %.18 s , l o g ( norm ( z1 ) ) ) ;

w r i t e f l n ( %.18 s , exp ( norm ( z1 ) ) ) ;

}

Figure 5: A complete D program showing use of creal. Substituting cdouble for creal employes a pair of

64 bit IEEE floating point numbers.

9

conj 1.41421356237309515+-1.41421356237309515i

norm 4.00000000000000089

2.00000000000000022

1.38629436111989084

54.5981500331442876

Some precision is perceptably lost during the calculations using 64 bits. Note in particular that to 18 decimal

places the abs is no longer exact using 64 bits.

D is a relatively recent programming language and current implementations may in fact use macros and other

apparatus hidden from the user to implement the D language on top of a C or C++ compiler. Consequently

the complex package may in fact be implemented as some overloaded operators that invoke the library

routines or other macros from a C/C++ complex.h package.

Although the definition of the complex modulus is:

p

|a + ib| = a2 + b2 (24)

This is not a numerically safe way to compute it as this can result in drastic error if either the real or

imaginary parts are comparable with the square root of the largest representable number. A safer way to

perform this calculation is:

( p

|a| 1 + (b/a)2 , |a| |b|

|a + ib| = p (25)

|b| 1 + (a/b)2 , |a| |b|

A similar issue arises with complex division and a numerically safe way to avoid potential overflow is to use

(the somewhat cumbersome) formulation:

(a+b(d/c))+i(ba(d/c))

c+d(d/c) , |c| |d|

a + ib (a+b(d/c))+i(ba(d/c))

= c+d(d/c) , |c| |d| (26)

c + id

(a(c/d)+b)+i(b(c/d)a)

c(c/d)+d , |c| |d|

Complex square roots need also be approached carefully with a multi-branch formula:

0, w=0

d

w + i , 6 0, c 0

w=

2w

c + id = |d| (27)

2w + iw, w 6= 0, c 0, d 0

|d|

2w iw, w 6= 0, c 0, d 0

10

where:

0, c=d=0

r

q

1+ 1+(d/c)2

w= |c| |c| |d|

2 , (28)

r

q

|d| |c/d|+ 1+(c/d)2 , |c| |d|

2

Unfortunately these safe but slower algorithms are often not implemented in complex.h packages and

therefore C++ and potentially D implementations that are built upon them are not necesarily safe against

overflows. It is not; however, difficult to adapt the necessary overloaded operators as defined in the system

include files for open compiler implementations.

More information on the effect of overflow in complex numbers is available in [4, 5].

Very modern interpreted environments such as the interpreted language Python [6] now typically come with

built in support for complex arithmetic. In Python the numeric literal j is used as a suffix to denote an

imaginary number. Figure 6 is a fragment of Python code illustrating the use of complex numbers.

#! / u s r / l o c a l / b i n / p y t h o n

print 1 + 2j

a = 1234.0 + 5678.0 j

print a . r e a l

print a . imag

Figure 6: A short Python program showing the built in support for complex numbers using the numeric

literal j.

(1+2j)

(1-2j)

1234.0

5678.0

Other scripting languages such as Ruby [7] require a library package to support complex arithmetic, but do

in fact have a richer set of associated functions and operators.

11

9 Summary

In summary, complex numbers are readily programmed in several modern programming languages although

users must sometimes still give care and attention to precision and overflow issues, depending upon the needs

of applications. Many systems will either support complex arithmetic using built in types or will simply

require inclusion of a standard supplied library or package to enable them.

References

[1] Garnatz and Grovender Inc: Jfront (2008)

[2] Metcalf, M., Reid, J., Cohen, M.: Fortran 95/2003 Explained. Oxford University Press (2004) ISBN

0-19-852693-8.

[4] Knuth, D.: The Art of Computer Programming: Seminumerical Algorithms. 3rd edn. Volume 2. Addison-

Wesley (1997)

[5] Midy, P., Yakovlev, Y.: Computing some elementary functions of a complex variable. Mathematics and

Computers in Simulation 33 (1991) 3349

[7] Thomas, D., Fowler, C., Hunt, A.: Programming Ruby: The Pragmatic Programmers Guide. 3rd edn.

Pragmatic Programmers (2004) ISBN 978-0-9745140-5-5.

12

- Java mock tests for SCJPUploaded byThyagarajan
- PraList C++Uploaded bySyed Mubashir Nazir
- IGate Placement PaperUploaded byPhanindra Babu Pabba
- B.E & B.Tech. Syllabs for Information Technology 3 SemesterUploaded byShashi Shekhar Sharma
- csc111-tutorial07_1Uploaded byOsama Maher
- Java Programming ConceptsUploaded byapex_tgi
- CUploaded byNitin Jadam
- Summer Practice Ias 13 EnUploaded byMihaela Enache
- rpcUploaded bySarath Pathari
- Multiple Choice Questions c LanguageUploaded byQamar Nangraj
- Complex NumbersUploaded byHubert Semeniano
- Rev Chapter 4 Complex NumbersUploaded byKwongKH
- theory of equationUploaded bySuman Ghosh
- Mcq 8Uploaded bythareenda
- ch03Uploaded bydnh
- Disadvantages in C LanguageUploaded byKumar Arikrishnan
- apr11certsdreportUploaded byJessica Tiffany
- Assignment 06Uploaded byAyushNil
- Overview dari Bahasa CUploaded byAsaCircle
- Function Point SpecialistUploaded byavinashkakarla
- Dip Dip Diploma in Computer EnggUploaded byRashmi Shankar
- A Brief Discussion on Nth RootsUploaded byAkash Sarkar
- Java 2Uploaded byFrancisco J. Piedrahita N
- Week3 Discussion QnsUploaded byRsTylecstAcy-
- New Text Document (4)Uploaded byAnkur Saxena
- SYLLABUS for Fybsc Physics Wef 2012-13Uploaded byriteshgajare
- C language QuestionsUploaded byGanesan Mu
- Subject Wise Preparation for Different IT CompaniesUploaded byDivyanshu Sharma
- [Cecil Smith] Distillation Control an Engineering(BookSee.org)Uploaded byMohamed Guenoune
- Complex NumbersUploaded byjgreenguitars

- Truong Vinh KyUploaded byQuang Hoang
- Cloud Computing OverviewUploaded byRahul Kumar
- Bien Giac Mo Thanh Suc Manh Di ToiUploaded byQuang Hoang
- Chuong 1_Muoi Nguyen Ly Cua Kinh Te HocUploaded byNguyễn Sơn Tùng
- Bien giac mo thanh suc manh di toi.pdfUploaded byQuang Hoang
- Harmonic Analysis Using Neural NetworksUploaded byQuang Hoang
- Data Structures Algorithms TutorialUploaded byKosma Kosmic
- Cach Dung Gia Pha, To PhaUploaded byQuang Hoang
- UML SolutionsUploaded byQuang Hoang
- Ly Thuyêt ve Guitar AcousticUploaded byThanh Nguyên
- Gọi Người Yêu Dấu (NXB Minh Huyền 1974) - Vũ Đức Nghiêm, 34 Trang.pdfUploaded byQuang Hoang
- Jazz Piano Comping EnsambleUploaded byJoaquín Carrillo Finck
- nhac guitaUploaded bybi_hpu2
- Tuyển Tập Những Ca Khúc Yêu Thích Trên Lan Sóng Xanh (NXB Phương Đông 2010)Uploaded byQuang Hoang
- Giữ Đời Cho Nhau - Từ Công Phụng, 29 TrangUploaded byQuang Hoang

- CHM3010+module+thermodynamic-ansUploaded bynur hashimah
- Using Coils for Extending WorkloadUploaded byMorosanu Andreea-Diana
- MQUploaded byIshwarya Senthil
- CoE 111 Probset 2Uploaded byPao Yap
- Getting Started on Your PeopleSoft UpgradeUploaded byiceyroses
- IT ManagerUploaded byapi-77396500
- 1 ... Session Notes - Issues in ELT Paper Two Task Three M1_W3_3a IssuesMoodleNotes2015versionUploaded byNaserElrmah
- ancore-metalice-01Uploaded bySeby Deac
- Black BuckUploaded byabha khosla
- REPORTE PRODOM VENDOR 20-6-2015.xlsxUploaded byljv004
- Marci Shimoff InterviewUploaded byhanako1192
- a m motorsUploaded byGokul Krishnan
- modulo utmUploaded byCristian Javier C
- Polymer Flood Aplication ReportUploaded byMohamedSadek
- USSMARTPIPE_SmartPipe KAESERUploaded byseiman23
- BehaviorismUploaded byAbindra Raj Dangol
- Euro-NCAP-Frontal-Protocol-Version-6.0.2---0-0ba7731f-4866-40c8-8dc5-31db64d92f8d.pdfUploaded byhanumantha
- Week(1) Summary for Calc001x: Pre-University CalculusUploaded byIbrahim Omar
- Netflix Stats Report January 2018Uploaded bySantiago Fernandez Moreno
- Dual Fly Back Dc Dc ConverterUploaded byThavva Ganesh
- strategic management-chapter2Uploaded byOceanus Hyori
- Dual Power SupplyUploaded byiwan
- MoHUA Retirement Homes Model Guidelines BookUploaded byMoneylife Foundation
- Economic Justice Under Indian Constitution (eBook, 1989) [WorldCatUploaded bycharvin
- Principles of ICU VentilatorsUploaded byAnanya Nanda
- synergyUploaded byapi-359784889
- Ervin_Laszlos_Holofield_The_Akasha_and_D.pdfUploaded byGuido Andreolli
- Frequency ResponseUploaded byAbram Vixen Reyes
- Taco vs TraliUploaded byOdiet Revender
- ResumeUploaded byHarrison Rogers