Category : C++ Source Code
Archive   : ZPP10.ZIP
Filename : COMPLEX.DOC

Z++ Version 1.0

Copyright 1992 by Carl Moreland
04/03/92

Z++ is a public domain complex number class written in C++. The distri-
buted files are:

complex.h header file for Z++
complex.cpp source code for Z++
complex.doc this file
z_test.cpp demonstration of complex numbers
fft.cpp fft using Z++
signal.dat data file for testing the fft

To use the complex number class, simply #include "complex.h" in your source
and add complex.cpp to the project or make file. You may use and distribute
this code freely, but all distributed copies must be unmodified, and there
may be no distribution charges. Comments, suggestions for improvement, and
bug reports may be sent to me via CompuServe (72137,2657), or mail them to:

Carl Moreland
4314 Filmore Rd
Greensboro, NC 27409

---------------------------------------------------------------------------
---------------------------------------------------------------------------

Introduction:

---------------------------------------------------------------------------
Complex numbers may be declared or initialized in the following ways:

complex z; // z is initialized to (0,0)
complex z(3); // z = (3,0)
complex z = 3; // z = (3,0)
complex z(3,4); // z = (3,4)
complex z = complex(3,4) // z = (3,4)
complex z = x; // set equal to a double/float/int
complex z1 = z2; // set equal to another complex

Uninitialized complex variables are set to (0,0) by the default construc-
tor, and variables that are set equal to a single number have their imagi-
nary part set to zero.

The following operators are available:

= see above
+ += addition
- -= subtraction
* *= multiplication
/ /= division
^ power (z1^z2)
== != comparison

The following functions are available:

re real part
im imaginary part
real real part
imag imaginary part
mag magnitude (sqrt(x**2 + y**2))
arg argument (atan(y/x))
ang angle (same as argument)
ph phase (same as argument)
conj complex conjugate (x, -y)
norm norm (x**2 + y**2)
abs absolute value (same as magnitude)
sqrt square root
pow power
exp exponential
log natural log
ln natural log
log10 log (base 10)
cos cosine
sin sine
tan tangent
acos arccosine
asin arcsine
atan arctangent
cosh hyperbolic cosine
sinh hyperbolic sine
tanh hyperbolic tangent
rtop rectangular-to-polar conversion
ptor polar-to-rectangular conversion
topolar converts z to polar form
torect converts z to rectangular form

SetArgMode ¿
SetPrintMode à See text below
SetLetter Ù

---------------------------------------------------------------------------

Most features of Z++ are standard. However, there are a few things that
are unique and should be explained.


The conversion functions rtop() and ptor() accept a complex number as
the argument and return a new complex number as the converted result. The
member methods topolar() and torect() will convert the instance internally
and return a reference to it. Remember though that all math functions ex-
pect arguments in rectangular notation, not polar. If you convert a number
to polar and try to take the cosine, for instance, you will not get the
correct results.


There are two modes that can be set in Z++. The argument mode deter-
mines whether complex arguments (from the functions arg(), ang(), & ph())
are returned in radians (the default) or degrees. This mode can be set by
calling the function SetArgMode() with either Z_RADIANS or Z_DEGREES as
the mode parameter:

z1.SetArgMode(Z_DEGREES);

Because this mode is represented as a static class variable, setting it
will affect all complex numbers. The command above appears to set this mode
only for instance z1, which is not true. To eliminate this confusion, there
is a static instance named Complex declared in complex.h which should be
used to set this mode:

Complex.SetArgMode(Z_DEGREES);

Either way will work, but the second has the appearance of being global.


The other mode is the print mode which affects the format of cout. This
mode can be set by calling the function SetPrintMode() with either Z_COMMA
or Z_LETTER as the mode parameter:

Complex.SetPrintMode(Z_COMMA)
Complex.SetPrintMode(Z_LETTER)

The first mode causes complex numbers to printed with the format (x, y) by
cout. The second mode causes them to be formatted as x ñ iy. Like the argu-
ment mode, this mode is global for all complex numbers and therefore should
be set using the Complex instance.


Electrical engineers prefer to use the letter j as the complex operator
(the letter i denotes AC current). There is a function called SetLetter()
which accepts a character argument:

Complex.SetLetter('j');

If the print mode is set to Z_LETTER then cout will print a complex number
with the format x ñ jy.


Finally, besides the instance Complex used above there are four other
static instances declared:

Z0 = complex(0,0)
Z1 = complex(1,0)
Zi = complex(0,1)
Zinf = complex(HUGE_VAL, HUGE_VAL)

These are common useful numbers that can be used for assignments, compari-
sons, and equations.

---------------------------------------------------------------------------

FFT note:

The FFT program that is included was originally written in C and ran on
DOS, VMS, and Unix. It's purpose was to transform sinusoidal data from an
analog-to-digital converter and display the harmonics and relative bits of
accuracy. I have only converted the fft() routine to use the Z++ complex
numbers; the rest of the program remains pure C. The data file included for
testing the FFT is the actual results from a 12-bit ADC.