TFunctionParser
TComplexParser           
		  by Marianne H. Goeltl-Schuberth

TFunctionParser and TComplexParser are non-visual DELPHI components for evaluating 
mathematical functions. 
The function term is a user given string like 'sin(x)*x'. The function term can be
changed during runtime.
TFunctionParser provides about 80 mathematical intrinsic functions and operations.
TComplexParser can evaluate about 30 complex predefined functions and operations.
The user can define functions, constants and variable names himself.

Contents:
  1. Features 
  2. Information 
  3. Installation and Registration
  4. Properties, Methods, Events
  5. The Component TParserDeclarations
  6. The Object TComplex
  7. Recommended Use 
  8. Sample programs
  9. List of operations and functions



1. Features 

	- Algebraic syntax, not case sensitive
	- Parentheses ()
	- Floating point numbers (extended); TComplex for TComplexParser
        - Angles in radians, degrees or gons (only TFunctionParser)
	- Userdefined variablenames (default: x, y, z and t)
	- Implemented mathematical constants
	- Userdefined constants 
	- About 80 predefined mathematical functions and operations in TFunctionParser
	- About 30 predetined complex functions and operations in TComplexParser
	- Userdefined functions based on the predefined ones (macros)
	  functions can be inserted into other functions (e.g. 'f(g(sin(1/x))+x/2)*h(g(x-1);pi)')	
	- One special userfunction: YOUR own code is evaluated
	- Easy to use: see 8. Sample programs 

Note:
TFunctionParser V5.x and TComplexParser V2.x are NOT compatible with former versions. 


2. Information

TFunctionParser V5.1 and TComplexParser V2.1 are Shareware. 
You may test them for a period of 30 days.
They may be copied and distributed unmodified (complete ZIP-file, no single files).

If you use them in your non-commercial applications you must register both of them by 
sending 20 USD or 35 DM to the author.
The license basic fee for commercial use is 100 USD or 180 DM respectively.
Registered users of one of the former versions get a discount.
You will obtain the registration code then, that switches off the automatic initial info 
screen.
The registration code must not be passed on.

You are obliged to quote my copyright in all your applications and programs using 
TFunctionParser or TComplexParser (e.g. method ShowInfo).

Registered users may only use their respective versions themselves on only one single
computer. 

Non-commercial users are not allowed to demand payment for software they wrote using 
TFunctionParser or TComplexParser.
Commercial users intenting to resale their applications using TFunctionParser or 
TComplexParser must contact the author specifying the kind of their programs and 
estimated number of sales. 


My address is:
			Marianne H. Goeltl-Schuberth	
			Egerlandstr. 18	
			D-91083 Baiersdorf	
			Germany

         eMail:		schuberth@t-online.de  
	 URL:		http://home.t-online.de/home/schuberth/

When ordering your personal registration code please confirm that you read this file and 
agree to the license conditions. Quote the desired version. Don't forget your eMail or 
postal address. I would like to know where you obtained these components from.          

If you find any bug, please don't hesitate to inform me. Details (functions, arguments, ...)
would be helpful.
Any suggestions, questions, and comments are welcome.


----------------------------------
THE LEGAL DISCLAIMER
----------------------------------
THE INFORMATION AND CODE PROVIDED HEREUNDER (COLLECTIVELY REFERRED TO AS "SOFTWARE") IS 
PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT 
LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DAMAGES WHATSOEVER INCLUDING DIRECT, 
INDIRECT, INCIDENTAL, CONSEQUENTIAL, LOSS OF BUSINESS PROFITS OR SPECIAL DAMAGES, EVEN IF
THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 



3. Installation and Registration

The file PARSERS3.ZIP (for Delphi 3) or PARSERS2.ZIP (for Delphi 2) include
the following files:

		FDEMO.DPR			providing a simple demo application
		FDEMO1.DFM			for TFunctionParser (function plotter)
		FDEMO1.PAS			

		CDEMO.DPR			providing a simple demo application
		CDEMO1.DFM			for TComplexParser (complex calculator)
		CDEMO1.PAS			

		PARSERS3.DPK			source package (only in PARSERS3.ZIP)
		FCTPARS.DCU			containing the components 
		FCTPARS.DCR                     	  TFunctionParser, TComplexparser
		FCTPARS1.DCU				  and TParserDeclarations
		FCTPARS1.DFM
		FCTPARS2.DCU
		FCTPARS2.DFM
		FCTPARS3.DCU
		FCTPARS4.DCU

		PARSERS3.TXT or PARSERS2.TXT	short ASCII formatted Info
		FILE_ID.DIZ			dto.
		README.TXT			this file
  		NATCONST.DAT	        	selection of physical constants
                CHANGES.TXT			changes from older versions                          
		
For installing the components you need the files 
					PARSERS3.DPK  (only Delphi 3)
                                        FCTPARS.DCR
					FCTPARS.DCU
					FCTPARS1.DCU
					FCTPARS2.DCU
					FCTPARS3.DCU
					FCTPARS4.DCU
					FCTPARS1.DFM
					FCTPARS2.DFM.

For Installation under Delphi 3:

- Choose from the menu File | Open
- Select the filter "Delphi Source Package (*.dpk)"
- Select PARSERS3.DPK and click on Open
- Click on Install: The package is compiled first and then installed
- Confirm the information that new components have been installed by clicking on OK
- You find now on the palette, page MHGS: 
	TFunctionParser, TComplexParser, TParserDeclarations

For Installation under Delphi 2:
Attention: If you have already installed a former version of TComplexParser you must 
	   remove cplxprs.dcu from your library and path first.

- Choose from the menu Component | Install 
- Choose Add
- Choose Browse
- Select the file format *.DCU
- Select FCTPARS.DCU
- Choose OK and wait while the compiler adds the new component to your library 
- You find now on the palette, page MHGS: 
	TFunctionParser, TComplexParser, TParserDeclarations


Registration Notes:

If you are not a registered user the infoscreen will appear each time an instance of 
TFunctionParser or TComplexParser is created. Furthermore you can only run one instance 
per application. 
Unregistered use is limited to 30 days.
You can register by sending 20 USD or 35 DM (non-commercial), or 100 USD or 180 DM 
(commercial) to me.
I will send you your personal unique registration code then.  
- When the infoscreen is shown
- Click on Information 
- The information form is displayed 
- Click on Register !
- Type your registration code into the editfield of the inputbox
WARNING: Do not make changes there unless you keep a valid registration code!
	 You might not be able to start TFunctionParser or TComplexParser again without 
	 reinstalling them. 				 
- Restart Delphi 




4. Properties, Methods, Events

Input Properties

TFunctionParser.Declarations: TParserDeclarations
TComplexParser.Declarations : TParserDeclarations
	TFunctionParser and TComplexParser REQUIRE a TParserDeclarations component. Multiple 
	instances of TFunctionParser and TComplexParser may share one TParserDeclarations instance.
	TParserDeclarations contains defaults and enables the use of self defined functions,
	constants and variable names.
	If you restrict on default settings there is no need to make changes to TParserDeclarations.
	Otherwise you should read 5. TParserDeclarations for more information.

TFunctionParser.Term : string			(only runtime)
TComplexParser.Term : string			(only runtime)
	Term is a (huge) string (e.g. 'sin(x)') defining the given function. Spaces are 
	ignored. Lower or upper cases are not distinguished. Arguments of functions must 
	be in brackets. Multiple arguments in functions must be separated by semicola.

TFunctionParser.VarValues[name]: extended	(only runtime)
TComplexParser.VarValues[name]: TComplex	(only runtime)
	The variable values are stored in the array VarValues. The name is the variable name like
	it must have been declared in TParserDeclarations.VarNames. See 5. TParserDeclarations.
	Defaults are x, y, z and t.

TFunctionParser.UserFct : function(extended):extended	(only runtime)
TComplexParser.UserFct : function(TComplex):TComplex	(only runtime)	
	UserFct allows you to call a function whose code you wrote yourself. Your function
	must be declared as FUNCTION functionname(X:EXTENDED):EXTENDED. Then you can assign
	FUNCTIONPARSER.USERFCT:=functionname. (TComplexParser analoguously).
	Your function is accessed if you call 'USERFCT(x)' in the Term. Of 
	course you can rename it using TParserDeclarations.Functions.
	A sample of UserFct is given in FDEMO1.PAS or see 8. Sample Programs below..

TFunctionParser.Anglemode : TAnglemode=(RAD, DEG, GON)	
	Only relevant for trigonometric functions and their inverses (arc functions).
        If TFunctionParser.Anglemode is RAD the unit for angles is radians (full angle 
	=2*pi), if it is DEG the unit is degrees (full angle =360), and if it is GON the
	unit is gons (full angle =400 gons).

TFunctionParser.About : boolean
TComplexParser.About
	indicate whether the infoscreen is shown. 

TFunctionParser.Data : pointer
TComplexParser.Data : pointer
	You may add an arbitrary object or pointer to TFunctionParser or TComplexParser. This is for
	your own use only. It doesn't interact with TFunctionParser or TComplexParser themselves. 


Output Properties:

TFunctionParser.Result : extended	(only runtime)
TComplexParser.Result : TComplex	(only runtime)
	When you read the Result, the Term is evaluated and the function value returned.

TFunctionParser.ErrorCode : byte 	(only runtime)
TComplexParser.ErrorCode : byte 	(only runtime)
	If an error occurs the ErrorCode is set according to the following list:

	0	everything is OK
	1	wrong parentheses / semicola
	2	Syntax error / invalid term
	3	unknown identifier
	4	recursive function or constant
	5	wrong number of operands
	6	term is not analyzed
	7	function is not defined for argument(s)
	9	declarations not assigned

	You should check ErrorCode after assigning the term and after reading the result.


TFunctionParser.Errormessage : string 
TComplexParser.Errormessage : string 
	The Errormessage gives you verbal information on the errors that occured.
	With a resource editor (e.g. Borland Resource Workshop) you can change the text of
	the errormessages in your executable program (only Delphi 3). 

TFunctionParser.Version : string
TComplexParser.Version: string
	indicates the used version.


Methods

TFunctionParser.ShowInfo
TComplexParser.Showinfo
	If you want to see the infoscreen call ShowInfo.
	The minimum display time is 3 seconds. ShowInfo is AUTOMATICALLY executed when
	creating an instance of TFunctionParser or TComplexParser if you are not registered.


Events

TFunctionParser.OnError
TComplexParser.OnError
	The most common errors (syntax error, division by zero, ...) will raise the event OnError.
	


5. The Component TParserDeclarations

TParserDeclarations is a component that is required by TFunctionParser and TComplexParser. It 
contains default settings and enables the definition of your own function macros, constants and
variable names.
Multiple instances of TFunctionParser or TComplexParser may share one instance of TParserDeclarations.
You MUST assign the Declarations property of TFunctionParser or TComplexParser to a TParser-
Declarations instance.
There is no need to make any changes to TParserDeclarations if you restrict on the default settings.

Properties of TParserDeclarations:
 
TParserDeclarations.VarNames: TStringlist
	You can define variable names in this stringlist. Default are x, y, z and t.
	Each variable name must stand in a separat line.
	You may make comments in the same lines, after a '#'-sign (e.g. 'x	#that is x');

TParserDeclarations.Constants : TStringlist
	You can define an arbitrary number of constants in TParserDeclarations.Constants 
	using the notation e.g. 'A1=1.5e-3' (cf. examples in NATCONST.DAT). 
        For TFunctionParser it is even possible to define constants like 'A2=sin(pi/4)' or 'A3=A2-A1' 
        Warning: The call of variable names (e.g. 'A4=exp(y)') will lead to wrong results,
	because 0 is inserted (A4 gets 1). No errorevent is raised in this case.
        You may not call constants recursively (e.g. 'A5=sqr(A5+1)') or crosswise 
	(e.g. 'A6=A7', 'A7=A6').
	TComplexParser understands only numbers that are either real (e.g. 2.3e-2) or imaginary
	(e.g. -5.6i)
	The constant identifiers must be unique. Otherwise the first one in the list is 
	taken. 
	Reserved abbreviations for identifier are e, pi, C, TRUE and FALSE for TFunctionParser 
	and e, pi, C and i (or j) for TComplexParser. The values of these numbers
	will overwrite your definitions.
	The sequence of the definition of the constants doesn't	matter. You may even add 
	your own comments in separat lines.

TParserDeclarations.Functions : TStringlist
	In this list you can define functions (macros) that are based on the intrinsic 
	functions. For example: 'F(X;Y)=EXP(X)*COS(Y)'. 
	You must specify the arguments in brackets and separated by semicola on the left side. 
	There must be at least one argument.
	The programmer is responsible for correct syntax and unique identifiers. 
	Userdefined functions may depend on other userdefined funclions, like e.g.
	'G(X)=SQR(F(X;PI))
	Recursive or crosswise calls are not allowed.
	Warning: If you use identifiers of predefined functions (e.g. SIN(X)) the latter
	ones are overwritten.
	Your own comments may be included after a '#'-sign.
	See also 8. Sample Programs
	
Naming Conventions for Variables, Functions and Constants
The first character must be alphabetical. The remaining characters may be alphabetic or
numerical. Special symbols are not supported (no underscore !). Identifiers must be unique.

TParserDeclarations.Data : pointer
	You may add an arbitrary object or pointer to TParserDeclarations. This is for
	your own use only. There is no influence on the behaviour of TParserDeclarations.

TParserDeclarations.ErrorMessage : string 	(only runtime)
	You can read the ErrorMessage for checking the correctness of the function macros
	and the variable names. Even if there are some invalid functions or variables, that will
	not necessarily affect the evaluations.



6. The Object TComplex

A mathematical complex number z consists of real part and imaginary part. You may write:
z=Re(z)+i*Im(z). Real and imaginary parts are real numbers each. "i" is the imaginary unit
with i=sqrt(-1).
The complex conjugate ~z=Re-i*Im.
The type TComplex used for TComplexParser is an object with the following properties and 
methodes:
	Re: extended			real part
	Im: extended			imaginary part
	Abs: extended			yields the absolute |z|>=0
	Arg: extended			yields the argument (phase), -pi< Arg <= pi
	Create(x,y: extended)		constructs an instance of TComplex with Re=x, Im=y
	CreatePolar(r,phi: extended)	constructs an instance of TComplex with Abs=r, Arg=phi
	Assign(z: TComplex): TComplex	assigns z to the instance
	Put(x,y: extended)		sets the real part to x and the imaginary part to y
	PutPolar(r,phi: extended)	sets the absolute to r and the phase to phi
	AsString: string		converts Re and Im into a string.

Arg yields a value between -pi and +pi. It takes the signs of Re and Im into account.

For transforming polar coordinates Abs and Arg to cartesian coordinates Re and Im use the
following formula:

	Re=Abs*cos(Arg),		Im=Abs*sin(Arg).

The inversion of this transformation is:

	Abs=sqrt(Re^2+Im^2),		Arg=arctan(Im/Re) if Re > 0.


Many complex functions are ambiguous because of the periodicity of Arg. TComplexParser 
always yields only ONE result (main part).

For further calculation rules of complex numbers consult the respective mathematical 
literature.
Various applications for calculating with complex numbers are found in science and 
engineering (e.g. conformal transformations, gain and phase of alternating currents, 
solving of some differential equations, ...).


IMPORTANT:
If you want to work with TComplex explicitly you must include FCTPARS3 to your uses-clause.
 
Some people prefer "j" as abbreviation for the imaginary unit. If you included FCTPARS3
you can change the global variable IMAGLETTER:='j'. IMAGLETTER is used by TComplex.AsString
for output and TComplexParser.Term for input. Default for IMAGLETTER is "i".

Defining TComplexParser.Term you can write a complex number (e.g. 1-0.5*i) in one of the
following ways (if IMAGLETTER='i', i.e. unchanged):
	1-i0.5		1-0.5i		-0.5i+1		-i0.5+1
or something like  sqrt(5)/2*exp(-i*arctan(0.5)). 



7. Recommended Use

For working with TFunctionParser or TComplexParser you should perform the following steps.
Necessary steps are indicated by consecutive numbers. Letters mark optional steps that may
be omitted if you don't want to use the respective features.

(*1*) 	You need an instance of TParserDeclarations. 
	Choose it from the palette, page MHGS, or create it at runtime.

(*2*)	You need an instance of TFunctionParser or TComplexParser.
	Choose it from the palette, page MHGS, or create it at runtime.

(*3*)	Set the T*Parser.Declarations property to your TParserDeclarations instance. 
	That is the most important step ! At design time or runtime.
	
		Optional: (at design time or runtime)
		(*Aa*)	-Change TParserDeclarations.Functions 
		(*Ab*)	-Change TParserDeclarations.VarNames  
		(*Ac*)	-Change TParserDeclarations.Constants 
		(*B*)	-Change TFunctionParser.AngleMode

(*4*)	Set T*Parser.Term to the desired function term (only runtime)
		
		Optional: (only runtime)
		(*Ca*)	-Check TParserDeclarations.ErrorMessage
		(*Cb*)	-Check T*Parser.ErrorCode or ErrorMessage

(*5*)	Set all required variable values (only runtime)

		Optional: (only runtime)
		(*D*)	-Set the user function

(*6*)	Read T*Parser.Result (only runtime)

		Optional: (only runtime)
		(*Ca*)	-Check T*Parser.ErrorCode or ErrorMessage




8. Sample Programs:

The following procedure shows the general use of TFunctionParser.

A simple calculator program may contain the following code.
Clicking on a button will induce the program to read the function term and the variable 
value from the respective edit fields, evaluate these, and write the result as the 
caption of a label. 

procedure TForm1.BitBtn1Click(Sender: TObject);
//(*1*) to (*3*) were done at design time 
begin
   with FunctionParser1 do begin
    Term:=edit1.text;					(*4*)
		{e.g. Term:='sin(x)/x'}
    VarValues['x']:=strtofloat(edit2.text);		(*5*)
		{'x' must be defined as variable name in ParserDeclarations1.VarNames} 
    label1.caption:='Result = '+floattostr(Result)	(*6*)
    if ErrorCode<>0 then label1.caption:=ErrorMessage;  (*Ca*)
   end;
   {It is indeed that easy to program a calculator}
end;

---------

You can build compositions of userdefined functions.
Either define them at design time with the help of the object inspector or at runtime.
You can use any method of the TStrings object for this purpose. 
At design time you could have used the stringlist editor to include the following lines to
ParserDeclarations1.Functions:
	#(*Aa*)
	F1(X)=SIN(X)+F2(X)
	F2(X)=SIN(X)*X
	F3(X)=J(3;X)
	F4(X)=F1(X)+F3(X)
	G(a;b;x)=IF((a<x)and(x<b);x;0) #=x if x is between a and b 
	H(beta)=g(f1(beta);f3(beta);beta-pi)	# senseless sample

The following code demonstrates how to define the user function (*D*) and adds a function 
(*Aa*) and constants (*Ac*).

function twice(x:extended):extended; {sample user function}
begin
 result:=2*x;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
   FunctionParser1.Userfct:=twice;        (*D*)
   FunctionParser1.Declarations.Functions.Add('TWICE(ABC)=USERFCT(ABC)'); (*Aa*)
               {the userfunction is set to the function above and renamed}
   FunctionParser1.Term:='twice(exp(x/5))+odd(round(x))'; (*4*) {Term is initialized here}
   ParserDeclarations1.Constants.loadfromfile('Natconst.dat'); (*Ac*)
               { includes physical constants}
end;


9. List of Operations and Functions

The separator between multiple arguments in functions is the semicolon (;). 
This character was choosen because the comma (,) is used as decimal separator 
in some countries.
Some Operators require their arguments in parentheses.
The second column specifies the availability for TFunctionParser (f) or TComplexParser (c). 
Capital letters indicate new functions.

Adding:			fc	x + y   	adds x and y
Subtracting:		fc	x - y   	subtract y from x
Multiplying:		fc	x * y		multiplies x and y
			f 	fac(n)		factorial of n, n!	
Dividing:		fc	x / y		divides x through y
			f	(n) div (m)	integer division
			fC	rez(x) 		reciprocal value of x
			f	(n) mod (m)	integer modulo
			f	modulo(x;y)	rest of division x/y
Powers:			f	x ^ y		x to the power of y
			fC	sqr(x) 		square of x
			fc	exp(x) 		exponential of x
Roots:			fc	sqrt(x)		squareroot of x
			f	cbrt(x) 	cubic root of x
			f 	root(n;x)	n-th root of x
Logarithms:		fc	ln(x)		log. with base e of x
			f	lg(x)		log. with base 10 of x
			f	lb(x)		log. with base 2 of x
			f 	log(b;x)	common log. with base b of x
Trigonometric Functions:fc	sin(x)		sine of x
			fc	cos(x)		cosine of x
			fc	tan(x)		tangent of x
			fc	cot(x)		cotangent of x
Arc Functions:		fc	arcsin(x)	arc sine of x
			fc	arccos(x)	arc cosine of x
			fc	arctan(x)	arc tangent of x
			f 	atan2(x;y)	arc tangent of y/x
			fc	arccot(x)	arc cotangent of x
Hyperbolic Functions:	fc	sinh(x)		hyperbolic sine of x
			fc	cosh(x)		hyperbolic cosine of x
			fc	tanh(x)		hyperbolic tangent of x
			fc	coth(x)		hyperbolic cotangent of x
Area Functions:		fc	arsinh(x)	inverse hyperbolic sine of x
			fc	arcosh(x)	inverse hyperboloc cosine of x
			fc	artanh(x)	inverse hyperbolic tangent of x
			fc	arcoth(x)	inverse hyperbolic cotangent of x
Statistical Function:	f	gauss(x)	normal distribution of x
			f	erf(x)		error function of x
			f	inverf(x)	inverse of error function of x
			f	(n) over (k)	binomial coefficient n over k
			f 	bino(n;k)	binomial coefficient n over k
			f 	poisson(mu;n)	poisson distribution of n with average mu
Random Numbers:		f	rnd(x)		random number in [0,x[ 
			f 	rand(x;y)	random number in [x,y[
Bessel Functions:	f	J0(x)		0th order of x
			f	J1(x)		1st order of x
			f	J2(x)		2nd order of x
			f	J3(x)		3rd order of x
			f	J4(x)		4th order of x
			f	J5(x)		5th order of x
			f 	J(n;x)		n-th order of x
Integral Functions:	f	Si(x)		sine integral of x 
			f	Ci(x)		cosine integral of x
			f	Ei(x)		exponential integral of x
			f	li(x)		logarithm integral of x
Gammafunction:		f	gamma(x)	gamma function of x
Stepfunctions:		f	theta(x)	=1 if x>0, else =0
			f	sgn(x)		signum function of x
			f	int(x)	        integer part of x
			F	round(x)	x rounded to next integer value
			F	ceil(x)		x rounded to higher integer value
			F	floor(x)	x rounded to lower integer value
Absolute Values:	f	abs(x)		absolute |x|
			f 	cabs(x;y)	absolute |x+iy|
Miscellaneous:		f	frac(x)		non-integer part of x
			f 	max(x;y)	maximum value of x and y
			f 	min(x;y)	minimum value of x and y	
			F	odd(n)		=1 if n is odd, =0 if n is even
Bitwise and Logical	f	(a) and (b)	bitwise logic AND
	Functions:	f	(a) or (b)	bitwise logic OR
			f	(a) xor (b)	bitwise logic XOR
			f	bnot(a)		bitwise NOT
			F	not(a)		logical NOT
			f	(a) shl (b)	shifts a b bitpositions to the left
			f	(a) shr (b)	shifts a b bitpositions to the right	
Relational Operators:	F	x = y		=1 if x is equal to y, else =0
			F	x <> y		=1 if x is not equal to y, else =0
			F	x <= y		=1 if x is less or equal to y, else =0
			F	x < y		=1 if x is less than y, else =0
			F	x >= y		=1 if x is greater or equal to y, else =0
			F	x > y		=1 if x is greater than y, else =0
Properties of complex	c	abs(z)		absolute |z|
	numbers:	c	arg(z)		argument (phase) of z
			c	re(z)		real part of z
			c	im(z)		imaginary part of z
			c	CC(z)		complex conjugate of z
			c	~z		complex conjugate of z
IF- Function:		F	if(c;x;y)	if condition c=1 then x, else if c=0 then y
User Function:		fc	userfct(x)	user implemented function
Mathematical Constants:	fc	pi		circumference/diameter of circle
			fc	e		base of natural logarithms
			fc	C		Euler's constant
			F	TRUE		logical value 1.0
			F	FALSE		logical value 0.0
                        c	i		imaginary unit, sqrt(-1)        



	Marianne H. Goeltl-Schuberth                                 