![]() | CMATH
Version 3
for C/C++ and for Pascal/Delphi |
OptiCode
Dr. Martin Sander Software Development Steinachstr. 9A D-69198 Schriesheim Germany http://www.optivec.com e-mail: support@optivec.com or sales@optivec.com |
CMATH is available both separately and as a part of OptiVec. If you ordered or downloaded CMATH alone, please disregard all references to OptiVec in this documentation.
If you got CMATH as a part of OptiVec, you may wish to refer to HANDBOOK.HTM for a description of the basic principles of the OptiVec libraries and an overview over VectorLib, the first part of OptiVec. The second part, MatrixLib is described in MATRIX.HTM.
Chapter 1.2 of this file contains the licence terms for the Shareware version, Chapter 1.3 for the Registered version.
OptiCode and OptiVec are trademarks of Dr. Martin Sander Software Dev. Other brand and product names mentioned in this handbook for identification purposes are trademarks or registered trademarks of their respective holders.
German-speaking users:
Um die Kosten für das Herunterladen der Shareware-Version über das Internet für alle so gering wie möglich zu halten, enthält diese nur die englische Dokumentation. Sie finden die deutsche Beschreibung separat unter http://www.optivec.com/download/CMDOCD.ZIP. |
Superior speed, accuracy and safety are achieved through the implementation in Assembly language (as opposed to the compiled or inline code of available complex C++ class libraries and to the unit Complex shipped with Delphi). Only for the most simple tasks, alternative inline C++ functions are used in the C++ version.
The implementation was guided by the following rules:
This documentation describes the CMATH implementations for
Here is a detailed description of how to switch from the complex classes of Borland C++ to the new implementation given by CMATH:
The data types fComplex, dComplex, eComplex, fPolar, dPolar, and ePolar are defined as synonyms for these classes.
In order to avoid the letter "L" (which is already over-used by long and unsigned long, extended is used as a synonym for long double in the Borland C++ version of CMATH. In the MSVC version, it is a synonym for double, as MSVC does not support 80-bit IEEE reals. Consequently, the complex data types of extended precision are named eComplex and ePolar. Thereby, the way is held open for a future inclusion of whole-number complex types into CMATH. Then, liComplex and ulComplex shall denote the complex types consisting of long int and unsigned long parts, respectively.
CMATH for Pascal/Delphi defines six complex data types:
type fComplex = record Re, Im: Single; end;
type dComplex = record Re, Im: Double; end;
type eComplex = record Re, Im: Extended; end;
type fPolar = record Mag, Arg: Float; end;
type dPolar = record Mag, Arg: Double; end;
type ePolar = record Mag, Arg: Extended; end;
The reason why the single-precision type gets the name fComplex instead of sComplex is that the letter "s" is already over-used by ShortInt and SmallInt in Pascal. Therefore, this name is derived from the C/C++ analogue of Single, which is float.
This is the Shareware version of CMATH ("SOFTWARE").
It may be used under the following licence terms:
Purchasing the full (registered) version gives you the right to use it on as many computers at a time as the number of units you bought.
The right to distribute applications employing functions of CMATH is included in the commercial-version licence. No run-time licence are needed for your customers! Corporate site and world-wide licences are available upon request.
The full versions (both the commercial and the educational editions) of CMATH
SWREG:
When ordering online through SWREG, please use the product-specific links below:
CMATH for C/C++
CMATH for Pascal/Delphi
Please choose the exact version and delivery options in the simple pulldown menu on the respective page.
ShareIt:
When ordering online through ShareIt, please use the product-specific links below:
CMATH for Borland C/C++
CMATH for Microsoft Visual C++
CMATH for Borland Delphi
CMATH for Borland (Turbo) Pascal
You may also order by e-mail to register@shareit.com.
US customers can also contact ShareIt! by telephone 1-724-850-8186 or FAX 1-724-850-8189 (only for orders, please).
Note the program No.:
commercial | educational | |
CMATH for Borland C/C++ | 101353 | 102655 |
CMATH for Microsoft Visual C++ | 103422 | 103441 |
CMATH for Borland (Turbo) Pascal | 103424 | |
CMATH for Borland Delphi | 103844 | 103860 |
If you have a European VAT ID, or if you order from outside the European Union, you are exempt from German VAT, and it will be deduced from your bill, but you may have to pay your local VAT and/or import duties according to local laws.
Please send a print-out of this order form to
OptiCode - Dr. Martin Sander Software Dev.
Steinachstr. 9A
D-69198 Schriesheim
Germany
FAX +49 - 6203 - 92 53 96
For any other questions related to ordering CMATH, please contact us at: sales@optivec.com
This is a single copy license for CMATH ("SOFTWARE"), granted by OptiCode - Dr. Martin Sander Software Development ("OptiCode").
The SOFTWARE in this package is licensed to you as the user. It is not sold. The term "user" means a programmer who links binary code of this SOFTWARE into his own applications. Those people using, in turn, his applications without the need of installing this SOFTWARE themselves, do not need any runtime license for the SOFTWARE. The right to distribute applications containing code of this SOFTWARE is included in the license fee for the commercial version.
Once you have paid the required license fee, you may use the SOFTWARE for as long as you like, provided you do not violate the copyright and if you observe the following rules:
If you got CMATH as a part of OptiVec, you should read chapter 1.4 of HANDBOOK.HTM instead of the remainder of the present paragraph. If you have already read that, continue with chapter 2, or go back to the Table of Contents.
To install CMATH, please follow these steps:
Platform | Memory Model | Required Processor | ||||
| ||||||
DOS | TINY |
| ||||
DOS | SMALL |
| ||||
DOS | MEDIUM |
| ||||
DOS | COMPACT |
| ||||
DOS | LARGE |
| ||||
DOS | HUGE |
| ||||
Windows | SMALL |
| ||||
Windows | MEDIUM |
| ||||
Windows | COMPACT |
| ||||
Windows | LARGE |
| ||||
32-bit Windows static run-time library dynamic run-time library | (FLAT) GUI or Console |
|
Target | Configuration | 486/Pentium library | Pentium III+ library |
single-thread | debug | CMVCSD.LIB | CMVCSD6.LIB |
single-thread | release | CMVCSR.LIB | CMVCSR6.LIB |
multi-thread | debug | CMVCMTD.LIB | CMVCMTD6.LIB |
multi-thread | release | CMVCMTR.LIB | CMVCMTR6.LIB |
multi-thread DLL | debug | CMVCMDD.LIB | CMVCMDD6.LIB |
multi-thread DLL | release | CMVCMDR.LIB | CMVCMDR6.LIB |
In C++, synonyms are defined for all these functions. The synonyms do not have a prefix, since the data type information is implicitly handled by the C++ compiler. The C++ function names are always identical to those found in the complex class libraries (if the respective function exists there), with the single exception of the member function polar, which had to be replaced by magargtoc, as the name "polar" had to be reserved for the polar classes. Of course, if you wish to use the C function names in your C++ modules, you can do so by including <cmath.h> instead of <newcplx.h>.
In the following, we denote the complex classes by by their short names, fComplex, fPolar, etc. In C++, you can always use the template nomenclature instead, writing "complex<float>" wherever "fComplex" is written here, and so on for all other complex types and classes.
Complex numbers are initialized by separately assigning a value to the imaginary and real parts or to the Mag and Arg parts, e.g.:
z.Re = 3.0; z.Im = 5.7;
p.Mag = 8.8; p.Arg = 3.14;
(Of course, for Pascal/Delphi, the assignment operator is written ":=").
Alternatively, the same initialization can be accomplished by the functions fcplx or fpolr:
C/C++:
z = fcplx( 3.0, 5.7 );
p = fpolr( 4.0, 0.7 );
Pascal/Delphi:
fcplx( z, 3.0, 5.7 );
fpolr( p, 3.0, 5.7 );
For double-precision complex numbers, use dcplx and dpolr, for extended-precision complex numbers, use ecplx and epolr.
Interconversions between the various complex types are performed via the functions:
cftocd, cdtocf, cftoce, cetocf, cdtoce, cetocd | up- or down-conversion of accuracy within the cartesian-complex types |
pftopd, pdtopf, pftope, petopf, pdtope, petopd | up- or down-conversion of accuracy within the polar-complex types |
cftopf, cftopd, cftope, cdtopf, cdtopd, cdtope, cetopf, cetopd, cetope | conversion from cartesian into polar complex |
pftocf, pftocd, pftoce, pdtocf, pdtocd, pdtoce, petocf, petocd, petoce | conversion from polar into cartesian complex |
C++ only: |
For C++ modules, there are several overloaded constructors as an alternative to the above functions:
basic forms: fComplex fComplex( float RePart, float ImPart=0 ); fComplex fComplex( dComplex ); fComplex fComplex( eComplex ); fPolar fPolar( float MagPart, float ArgPart=0 ); fPolar fPolar( dPolar ); fPolar fPolar( ePolar ); interconversion cartesian <--> polar: fComplex fComplex( fPolar ); fComplex fComplex( dPolar ); fComplex fComplex( ePolar ); fPolar fPolar( fComplex ); fPolar fPolar( dComplex ); fPolar fPolar( eComplex ); Similarly to the constructors fComplex() and fPolar(), also dComplex(), dPolar(), eComplex, and ePolar() exist in overloaded versions performing the same tasks for the classes dComplex, dPolar, eComplex, and ePolar, respectively. As described above for the C/Pascal/Delphi versions, OVERFLOW errors in the course of down-conversions are silently cured, without calling _matherr. |
The conversion between cartesian and polar format involves transcedental functions and is, therefore, quite time-consuming. It is true that multiplications are faster in polar coordinates, whereas additions are much faster in Cartesian. The difference, however, is so much smaller than the cost of switching back and forth between the different representations, that we recommend you stay in general with the cartesian format. Only in the following cases, the conversion really makes sense:
cartesian C/Pascal/Delphi function | polar C/Pascal/Delphi function | overloaded C++ function | explanation |
cf_conj | pf_conj | conj | complex-conjugate form |
cf_neg | pf_neg | neg (or -) | negation |
cf_real | pf_real | real | extraction of the real part |
cf_imag | pf_imag | imag | extraction of the imaginary part |
cf_magargtoc | N.A. | magargtoc | conversion of polar coordinates, entered as separate real numbers, into cartesian format |
N.A. | pf_reimtop | reimtop | conversion of complex coordinates, entered as separate real numbers, into polar format |
cf_abs | pf_abs | abs | absolute value (magnitude of the pointer in the complex plane; this is treated as a math function with error handling) |
cf_arg | pf_arg | arg | argument (angle of the pointer in the complex plane) |
cf_norm | pf_norm | norm | norm (defined here as the square of the absolute value) |
N.A. | pf_principal | principal | principal value, with -p < Arg <= +p |
Only C++: | The following set of operators is available for all of the three cartesian complex classes:
+ - * / += -= *= /= == != For the polar complex classes, we have: * / *= /= == != These operators exist also for "mixed" arguments, where one argument is complex, the other real and where the arguments are of different floating-point accuracies. |
Since it is only the language C++, but neither plain-C nor Pascal, which allows overloaded arithmetic operators, all arithmetic operations of complex numbers are implemented additionally as functions which may be called from C/Pascal/Delphi as well as C++ modules:
Cartesian | Polar | |
cf_add | N.A. | addition of two complex numbers |
cf_addRe | N.A. | addition of a complex number and a real number |
cf_sub | N.A. | subtraction of two complex numbers (first operand minus the second operand) |
cf_subRe | N.A. | subtraction of a real number from a complex number |
cf_subrRe | N.A. | subtraction of a complex number from a real number |
cf_mul | pf_mul | multiplication of two complex numbers |
cf_mulRe | pf_mulRe | multiplication of a complex number and a real number |
cf_div | pf_div | division of two complex numbers (first operand divided by the second operand) |
cf_divRe | pf_divRe | division of a complex number by a real number |
cf_divrRe | pf_divrRe | division of a real number by a complex number |
The assignment operator "=" or ":=" is the only operator defined also in plain-C and Pascal/Delphi for complex numbers.
cartesian C/Pascal/Delphi function | polar C/Pascal/Delphi function | overloaded C++ function | formula | explanation |
cf_abs | pf_abs | abs | ry = | zx | | absolute value |
cf_acos | N.A. | acos | zy = acos( zx ) | arcus cosine function |
cf_asin | N.A. | asin | zy = asin( zx ) | arcus sine function |
cf_atan | N.A. | atan | zy = atan( zx ) | arcus tangent function |
cf_cos | N.A. | cos | zy = cos( zx ) | cosine |
cf_cosh | N.A. | cosh | zy = cosh( zx ) | hyperbolic cosine |
cf_cubic | pf_cubic | cubic | zy = zx3 | third power |
cf_exp | cf_exptop | exp | zy = exp( zx ) | exponential function |
cf_inv | pf_inv | inv | zy = 1.0 / zx | inverse |
cf_ipow | pf_ipow | ipow | zy = zxn | integer power |
cf_ln | pf_lntoc | ln | zy = ln( zx ) | natural logarithm |
cf_log | pf_logtoc | log | zy = ln( zx ) | identical to cf_ln, pf_lntoc, ln |
cf_log2 | pf_log2toc | log2 | zy = lb( zx ) | binary logarithm |
cf_log10 | pf_log10toc | log10 | zy = lg( zx ) | decadic logarithm |
cf_pow | N.A. | pow | zy = zxzexp | arbitrary power |
cf_powReBase | N.A. | pow, powReBase | zy = rzx | real base to complex power |
cf_powReExpo | pf_powReExpo | pow, powReExpo | zy = zxr | real power of complex base |
cf_quartic | pf_quartic | quartic | zy = zx4 | fourth power |
cf_sin | N.A. | sin | zy = sin( zx ) | sine |
cf_sinh | N.A. | sinh | zy = sinh( zx ) | hyperbolic sine |
cf_square | pf_square | square | zy = zx2 | square |
cf_sqrt | pf_sqrt | sqrt | zy = sqrt( zx ) | square root |
cf_tan | N.A. | tan | zy = tan( zx ) | tangent |
cf_tanh | N.A. | tanh | zy = tanh( zx ) | hyperbolic tangent |
As noted above, the exponential and logarithm functions provide a natural transition between cartesian and polar coordinates. While there are exp and log functions for fComplex as argument and as return value, cf_exptop takes an fComplex argument and returns fPolar. In the opposite direction, pf_logtoc takes an fPolar argument and returns fComplex.
In contrast to the arithmetic operations, all mathematical functions and all data-type interconversions perform a tight error checking. All error messages eventually generated use the C/Pascal/Delphi name (rather than the overloaded C++ name) of the failing function.
If you got CMATH as a part of OptiVec, you should read chapter 5 of HANDBOOK.HTM rather than the present chapter.
Constant | Value | Meaning |
fperrIgnore | 0 | Ignore all floating-point errors: handle them silently, do not print a message, continue program execution |
fperrNoteDOMAIN | $0001 | Print a message in case of a DOMAIN error |
fperrNoteSING | $0002 | Print a message in case of a SING error |
fperrNoteOVERFLOW | $0003 | Print a message in case of an OVERFLOW error |
fperrNoteTLOSS | $0004 | Print a message in case of a TLOSS error |
fperrAbortDOMAIN | $0101 | Abort program in case of a DOMAIN error |
fperrAbortSING | $0202 | Abort program in case of a SING error |
fperrAbortOVERFLOW | $0303 | Abort program in case of an OVERFLOW error |
fperrAbortTLOSS | $0404 | Abort program in case of a TLOSS error |
fperrDefaultHandling | $0107 | Same as fperrAbortDOMAIN or fperrNoteSING or fperrNoteOVERFLOW |
You might wish to circumvent this. To this end, OptiVec and CMATH provide the function V_setErrorEventFile. This function needs as arguments the desired name of your event file and a switch named ScreenAndFile which decides if you wish to have error messages printed simultaneously into the file and onto the screen (ScreenAndFile = TRUE (non-zero)) or exclusively into the file (ScreenAndFile = FALSE (0)).
Example:
V_setErrorEventFile( "MyLogFil.TXT", 0 ); /* C/C++ */
V_setErrorEventFile( 'MyLogFil.TXT', FALSE ); (* Pascal/Delphi *)
Here, you will get all subsequent error messages only into your log file, MyLogFil.TXT and no messages on the screen. The default, i.e., printing error messages to the screen, is restored by V_closeErrorEventFile. (That function does not take any arguments and does not return anything.)
Note that this redirection of error messages is valid only for errors occurring in OptiVec (CMATH) routines. If you wish to do so, however, there is a way in C/C++ to extend the redirection also to the "non-OptiVec" functions: you may modify _matherr and _matherrl such that the statement
return 0;
(which signals an unresolved error) is replaced by the sequence
V_noteError( e->name, e->type ); return 1;
Thereby the task of printing the error message for unresolved errors is passed to the OptiVec function V_noteError which shall check if an error event file was defined or not and direct its output to the desired place. Keep in mind that it is the return value of _matherr which decides if an error message is printed by the default error handler of your compiler. Thus, after the call to V_noteError, the printing of the default error messages is by-passed by returning "1". (Also, do not forget that OptiVec / CMATH uses your _matherr routine to determine which errors you accept and which not!)
For example, your _matherr function (matherr - without the leading underbar - for Borland C++ 3.0 and 3.1) might look like the following one:
#include <math.h>
int _matherr( struct exception *e) /* "_exception" for MSVC */
{
if( (e->type == UNDERFLOW) || (e->type == TLOSS) ) ; /* ignore */
else /* all other errors deserve at least notice */
{
V_noteError( e->name, e->type );
if (e->type == DOMAIN) exit(1); /* really fatal */
}
return 1;
}
(Of course, if you decide to change _matherr, do not forget to change _matherrl in the same way, if you are using Borland C++!).
float cf_abs( fComplex __z );
function cf_abs( zx:fComplex ): Single;
float pf_abs( fPolar __p );
function pf_abs( px:fPolar ): Single;
fComplex cf_acos( fComplex __z );
procedure cf_acos( var zy:fComplex; zx:fComplex );
fComplex cf_add( fComplex __x, fComplex __y );
procedure cf_add( var zz:fComplex; zx, zy:fComplex );
fComplex cf_addRe( fComplex __x, float __yRe );
procedure cf_addRe( var zz:fComplex; zx:fComplex; yRe:Single );
float cf_arg( fComplex __z );
function cf_arg( zx:fComplex ): Single;
float pf_arg( fPolar __z );
function pf_arg( px:fPolar ): Single;
fComplex cf_asin( fComplex __z );
procedure cf_asin( var zy:fComplex; zx:fComplex );
fComplex cf_atan( fComplex __z );
procedure cf_atan( var zy:fComplex; zx:fComplex );
eComplex cdtoce( dComplex __zd );
procedure cdtoce( var zy:eComplex; zx:dComplex );
fComplex cdtocf( dComplex __zd );
procedure cdtocf( var zy:fComplex; zx:dComplex );
dPolar cdtopd( dComplex __zd );
procedure cdtopd( var py:dPolar; zx:eComplex );
ePolar cdtope( dComplex __zd );
procedure cdtope( var py:ePolar; zx:eComplex );
fPolar cdtopf( dComplex __zd );
procedure cdtope( var py:fPolar; zx:eComplex );
dComplex cetocd( eComplex __ze );
procedure cetocd( var zy:dComplex; zx:eComplex );
fComplex cetocf( eComplex __ze );
procedure cetocf( var zy:fComplex; zx:eComplex );
dPolar cetopd( eComplex __ze );
procedure cetopd( var py:dPolar; zx:eComplex );
ePolar cetope( eComplex __ze );
procedure cetope( var py:ePolar; zx:eComplex );
fPolar cetopf( eComplex __ze );
procedure cetopf( var py:fPolar; zx:eComplex );
dComplex cftocd( fComplex __zf );
procedure cftocd( var zy:dComplex; zx:fComplex );
eComplex cftoce( fComplex __zf );
procedure cftoce( var zy:eComplex; zx:fComplex );
dPolar cftopd( fComplex __zf );
procedure cftopd( var py:dPolar; zx:fComplex );
ePolar cftope( fComplex __zf );
procedure cftope( var py:ePolar; zx:fComplex );
fPolar cftopf( fComplex __zf );
procedure cftopf( var py:fPolar; zx:fComplex );
fComplex cf_conj( fComplex __z );
procedure cf_conj( var zy:fComplex; zx:fComplex );
fPolar pf_conj( fPolar __p );
procedure pf_conj( var py:fPolar; px:fPolar );
fComplex cf_cos( fComplex __z );
procedure cf_cos( var zy:fComplex; zx:fComplex );
fComplex cf_cosh( fComplex __z );
procedure cf_cosh( var zy:fComplex; zx:fComplex );
fComplex cf_cubic( fComplex __z );
procedure cf_cubic( var zy:fComplex; zx:fComplex );
fPolar pf_cubic( fPolar __p );
procedure pf_cubic( var py:fPolar; px:fPolar );
fComplex cf_div( fComplex __x, fComplex __y );
procedure cf_div( var zz:fComplex; zx, zy:fComplex );
fPolar pf_div( fPolar __x, fPolar __y );
procedure pf_div( var pz:fPolar; px, py:fPolar );
fComplex cf_divRe( fComplex __x, float __yRe ); /* x / yRe */
procedure cf_divRe( var zz:fComplex; zx:fComplex; yRe:Single );
fPolar pf_divRe( fPolar __x, float __yRe ); /* x / yRe */
procedure pf_divRe( var pz:fPolar; px:fPolar; yRe:Single );
fComplex cf_divrRe( fComplex __x, float __yRe ); /* yRe / x */
procedure cf_divrRe( var zz:fComplex; zx:fComplex; yRe:Single );
fPolar pf_divrRe( fPolar __x, float __yRe ); /* yRe / x */
procedure pf_divrRe( var pz:fPolar; px:fPolar; yRe:Single );
fComplex cf_exp( fComplex __z );
procedure cf_exp( var zy:fComplex; zx:fComplex );
fPolar cf_exptop( fComplex __z );
procedure cf_exptop( var py:fPolar; zx:fComplex );
fComplex fcplx( float __ReVal, float __ImVal);
procedure fcplx( var zy:fComplex; xRe, xIm:Single );
fPolar fpolr( float __MagVal, float __ArgVal);
procedure fpolr( var py:fPolar; xMag, xArg:Single );
float cf_imag( fComplex __z );
function cf_imag( zx:fComplex ): Single;
float pf_imag( fPolar __p );
function pf_imag( px:fPolar ): Single;
fComplex cf_inv( fComplex __z );
procedure cf_inv( var zy:fComplex; zx:fComplex );
fPolar pf_inv( fPolar __p );
procedure pf_inv( var py:fPolar; zx:fComplex );
fComplex cf_ipow( fComplex __z, int __exponent );
procedure cf_ipow( var zy:fComplex; zx:fComplex; exponent:Integer );
fPolar pf_ipow( fPolar __p, int __exponent );
procedure pf_ipow( var py:fPolar; px:fPolar; exponent:Integer );
fComplex cf_ln( fComplex __z );
procedure cf_ln( var zy:fComplex; zx:fComplex );
fComplex pf_lntoc( fPolar __p );
procedure pf_lntoc( var zy:fComplex; zx:fPolar );
fComplex cf_log( fComplex __z );
procedure cf_log( var zy:fComplex; zx:fComplex );
fComplex pf_logtoc( fPolar __p );
procedure pf_logtoc( var zy:fComplex; zx:fPolar );
fComplex cf_log2( fComplex __z );
procedure cf_log2( var zy:fComplex; zx:fComplex );
fComplex pf_log2toc( fPolar __p );
procedure pf_log2toc( var zy:fComplex; zx:fPolar );
fComplex cf_log10( fComplex __z );
procedure cf_log10( var zy:fComplex; zx:fComplex );
fComplex pf_log10toc( fPolar __p );
procedure pf_log10toc( var zy:fComplex; zx:fPolar );
fComplex cf_magargtoc( float __mag, float __angle );
procedure cf_magargtoc( var zy:fComplex; mag, angle:Single );
fComplex cf_mul( fComplex __x, fComplex __y );
procedure cf_mul( var zz:fComplex; zx, zy:fComplex );
fPolar pf_mul( fPolar __x, fPolar __y );
procedure pf_mul( var zz:fPolar; zx, zy:fPolar );
fComplex cf_mulRe( fComplex __x, float __yRe );
procedure cf_mulRe( var zz:fComplex; zx:fComplex; yRe:Single );
fPolar pf_mulRe( fPolar __x, float __yRe );
procedure pf_mulRe( var zz:fPolar; zx:fPolar; yRe:Single );
fComplex cf_neg( fComplex __z );
procedure cf_neg( var zy:fComplex; zx:fComplex );
fPolar pf_neg( fPolar __p );
procedure pf_neg( var py:fPolar; px:fPolar );
float cf_norm( fComplex __z );
function cf_norm( zx:fComplex ): Single;
float pf_norm( fPolar __p );
function pf_norm( px:fPolar ): Single;
dComplex pdtocd( dPolar __pd );
procedure pdtocd( var zy:dComplex; px:dPolar );
eComplex pdtoce( dPolar __pd );
procedure pdtoce( var zy:eComplex; px:dPolar );
fComplex pdtocf( dPolar __pd );
procedure pdtocf( var zy:fComplex; px:dPolar );
ePolar pdtope( dPolar __pd );
procedure pdtope( var zy:ePolar; zx:dPolar );
fPolar pdtopf( dPolar __pd );
procedure pdtopf( var zy:fPolar; zx:dPolar );
dComplex petocd( ePolar __pe );
procedure petocd( var zy:dComplex; px:ePolar );
eComplex petoce( ePolar __pe );
procedure petoce( var zy:eComplex; px:ePolar );
fComplex petocf( ePolar __pe );
procedure petocf( var zy:fComplex; px:ePolar );
dPolar petopd( ePolar __pe );
procedure petopd( var zy:dPolar; zx:ePolar );
fPolar petopf( ePolar __pe );
procedure petopf( var zy:fPolar; zx:ePolar );
dComplex pftocd( fPolar __pf );
procedure pftocd( var zy:dComplex; px:fPolar );
eComplex pftoce( fPolar __pf );
procedure pftoce( var zy:eComplex; px:fPolar );
fComplex pftocf( fPolar __pf );
procedure pftocf( var zy:fComplex; px:fPolar );
dPolar pftopd( fPolar __pf );
procedure pftopd( var zy:dPolar; zx:fPolar );
ePolar pftope( fPolar __pf );
procedure pftope( var zy:ePolar; zx:fPolar );
fComplex cf_polar( float mag, float arg ); /* same as cf_magargtoc */
procedure cf_polar( var zy:fComplex; mag, arg:Single );
fComplex cf_pow( fComplex __base, fComplex __exponent );
procedure cf_pow( var zy:fComplex; zx:fComplex; exponent:Integer );
fComplex cf_powReBase( float __base, fComplex __exponent );
procedure cf_powReBase( var zy:fComplex; base:Single; exponent:fComplex );
fComplex cf_powReExpo( fComplex __base, float __exponent );
procedure cf_powReExpo( var zy:fComplex; zx:fComplex; exponent:Single );
fPolar pf_powReExpo( fPolar __base, float __exponent );
procedure pf_powReExpo( var py:fPolar; px:fPolar; exponent:Single );
fComplex cf_quartic( fComplex __z );
procedure cf_quartic( var zy:fComplex; zx:fComplex );
fPolar pf_quartic( fPolar __p );
procedure pf_quartic( var py:fPolar; zx:fPolar );
float cf_real( fComplex __z );
function cf_real( zx:fComplex ): Single;
float pf_real( fPolar __p );
function pf_real( px:fPolar ): Single;
fComplex cf_sin( fComplex __z );
procedure cf_sin( var zy:fComplex; zx:fComplex );
fComplex cf_sinh( fComplex __z );
procedure cf_sinh( var zy:fComplex; zx:fComplex );
fComplex cf_square( fComplex __z );
procedure cf_square( var zy:fComplex; zx:fComplex );
fPolar pf_square( fPolar __p );
procedure pf_square( var py:fPolar; zx:fPolar );
fComplex cf_sqrt( fComplex __z );
procedure cf_sqrt( var zy:fComplex; zx:fComplex );
fPolar pf_sqrt( fPolar __p );
procedure pf_sqrt( var py:fPolar; px:fPolar );
fComplex cf_sub( fComplex __x, fComplex __y );
procedure cf_sub( var zz:fComplex; zx, zy:fComplex );
fComplex cf_subRe( fComplex __x, float __yRe ); /* x - yRe */
procedure cf_subRe( var zz:fComplex; zx:fComplex; yRe:Single );
fComplex cf_subrRe( fComplex __x, float __yRe ); /* yRe - x */
procedure cf_subrRe( var zz:fComplex; zx:fComplex; yRe:Single );
fComplex cf_tan( fComplex __z );
procedure cf_tan( var zy:fComplex; zx:fComplex );
fComplex cf_tanh( fComplex __z );
procedure cf_tanh( var zy:fComplex; zx:fComplex );
float arg( fComplex _z );
float arg( fPolar _p );
fComplex conj( fComplex _z );
fPolar conj( fPolar _p );
fComplex cubic( fComplex _z );
fPolar cubic( fPolar _p );
fComplex exp( fComplex _z );
fPolar exptop( fComplex _z );
fComplex fComplex( float Re_part, float Im_part=0 );
fComplex fComplex( dComplex cd );
fComplex fComplex( eComplex ce ); // type-casting constructors
fComplex fComplex( fPolar pf ); // interconversion from polar
fComplex fComplex( dPolar pd );
fComplex fComplex( ePolar pe );
float imag(); // to be used as zim = z.imag();
float imag( fComplex _z ); // to be used as zim = imag( z );
float imag( fPolar _p );
fComplex inv( fComplex _z );
fPolar inv( fPolar _p );
fComplex ipow( fComplex __base, int __expon );
fPolar ipow( fPolar __base, int __expon );
fComplex ln( fComplex _z );
fComplex lntoc( fPolar _p );
fComplex log( fComplex _z );
fComplex logtoc( fPolar _p );
fComplex log2( fComplex _z );
fComplex log2toc( fPolar _p );
fComplex log10( fComplex _z );
fComplex log10toc( fPolar _p );
fComplex magargtoc( float _mag, float _angle );
fComplex neg( fComplex _z );
fPolar neg( fPolar _p );
float norm( fComplex _z );
float norm( fPolar _p );
fComplex pow( fComplex __base, fComplex __expon);
fComplex powReBase( float __base, fComplex __expon );
fComplex pow( float __base, fComplex __expon);
fComplex powReExpo( fComplex __base, float __expon );
fComplex pow( fComplex __base, float __expon );
fPolar powReExpo( fPolar __base, float __expon );
fPolar principal( fPolar _p );
fPolar principal( floag __mag, float __arg );
fComplex quartic( fComplex _z );
fPolar quartic( fPolar _p );
float z.real(); // to be used as zre = z.real();
float real( fComplex _z ); // to be used as zre = real ( _z );
float real( fPolar _p );
fPolar reimtop( float _re, float _im );
fComplex sqrt( fComplex _z );
fPolar sqrt( fPolar _p );
fComplex square( fComplex _z );
fPolar square( fPolar _z );