Category : Miscellaneous Language Source Code
Archive   : LIBRY51.ZIP
Filename : LIBRY4A.DOC

.pa
QUICK LIST OF MATHEMATICAL FUNCTIONS

AERF..... arc-error function
APOLY.... area of a polygon
BETA..... complete beta function
BETAR.... incomplete beta function
BINML.... binomial coefficient
BINMLD... double precision form of BINML
CHEBY.... Chebyshev polynomial of N-th degree
DERF..... double precision error function
DERFC.... double precision complementary error function
DEXPI.... double precision exponential integral
DWSN..... Dawson's integral
ERF...... error function
ERFC..... complementary error function
EXPI..... exponential integral
FACT..... factorial
FGQ0I.... numerical integration from zero to infinity
FGQ0ID... double precision form of FGI0I
FGQ1..... numerical integration over definite interval
FGQ1D.... double precision form of FGQ1
FGQ2..... numerical integration over definite interval in 2 dimensions
FGQ2D.... double precision form of FGQ2
FGQ3..... numerical integration over definite interval in 3 dimensions
FGQ3D.... double precision form of FGQ3
FPG...... normal probability distribution in percent
FRF...... cubic error function
FTC95.... Student's T-distribution for 95% confidence
GAMAL.... natural log of the Gamma function for large values
GAMMA.... Gamma function
GXNYM.... numerical integration of X**N*Y**M*dXdY over polygonal region
IRAND.... random number generator (integer)
PLG0..... Legendre polynomial of N-th degree
PLG1..... Legendre polynomial of N-th degree (first derivative)
PLG2..... Legendre polynomial of N-th degree (second derivative)
PLG3..... Legendre polynomial of N-th degree (third derivative)
PPLG0.... Legendre polynomial of N-th degree in 2 dimensions
RPQ...... rational polynomial evaluation
RPQD..... double precision form of RPQ
SEVAL.... cubic spline evaluation
XRAND.... random number generator (real, normally distributed)
.pa
MATHEMATICAL FUNCTIONS


NAME: AERF
PURPOSE: arc-error function
TYPE: REAL*4 function (far external)
SYNTAX: X=AERF(E)
INPUT: E (REAL*4) the erf of something
OUTPUT: X (REAL*4) the arc-erf


NAME: APOLY
PURPOSE: area of a polygon
TYPE: REAL*4 function (far external)
SYNTAX: A=APOLY(X,Y,N)
INPUT: X,Y (REAL*4) an array of points (X,Y)
OUTPUT: A (REAL*4) the area enclosed
NOTE: points must be in the order you draw a "connect-the-dots"
picture, the connection between the last point and the first
point is assumed (e.g. for a triangular region N=3)


NAME: BETA
PURPOSE: complete beta function
TYPE: REAL*4 function (far external)
SYNTAX: B=BETA(X,Y)
INPUT: X,Y (REAL*4)
OUTPUT: B (REAL*4)


NAME: BETAR
PURPOSE: incomplete beta function
TYPE: REAL*4 function (far external)
SYNTAX: B=BETAR(X,Y,R)
INPUT: X,Y,R (REAL*4)
OUTPUT: B (REAL*4)


NAME: BINML
PURPOSE: binomial coefficient
TYPE: REAL*4 function (far external)
SYNTAX: B=BINML(N,I)
INPUT: N,I (INTEGER*2)
OUTPUT: B (REAL*4)


NAME: CHEBY
PURPOSE: Chebyshev polynomial of N-th degree
TYPE: REAL*4 function (far external)
SYNTAX: C=CHEBY(N,X)
INPUT: X (REAL*4), N (INTEGER*2)
OUTPUT: C (REAL*4)


NAME: DWSN
PURPOSE: Dawson's integral
TYPE: REAL*4 function (far external)
SYNTAX: D=DWSN(X)
INPUT: X (REAL*4)
OUTPUT: D (REAL*4)


NAME: ERF
PURPOSE: error function
TYPE: REAL*4 function (far external)
SYNTAX: E=ERF(X)
INPUT: X (REAL*4)
OUTPUT: E (REAL*4)
NOTE: for double precision use DERF


NAME: ERFC
PURPOSE: complementary error function
TYPE: REAL*4 function (far external)
SYNTAX: E=ERFC(X)
INPUT: X (REAL*4)
OUTPUT: E (REAL*4)
NOTE: for double precision use DERFC


NAME: EXPI
PURPOSE: exponential integral (Abramowitz & Stegun use the notation E1(X) in
their NBS publication "Handbook of Mathematical Functions"; it is
also called the "Theis Well Function" by groundwater folks; it is
the integral from X to infinity of EXP(-X)/X dX.)
TYPE: REAL*4 function (far external)
SYNTAX: E=EXPI(X)
INPUT: X (REAL*4)
OUTPUT: E (REAL*4)
NOTE: for double precision use DEXPI


NAME: FACT
PURPOSE: factorial
TYPE: REAL*4 function (far external)
SYNTAX: F=FACT(N)
INPUT: N (INTEGER*2)
OUTPUT: F (REAL*4)


NAME: FGQ0I (note the "0" (zero))
PURPOSE: numerical integration from zero to infinity
TYPE: REAL*4 function (far external)
SYNTAX: FI=FGQ0I(F)
INPUT: F (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence FX=F(X)
OUTPUT: the integral
NOTE: for double precision use FGQ0ID
20-point Gauss quadrature is used (96-point for double
precision)


NAME: FGQ1
PURPOSE: numerical integration over definite interval
TYPE: REAL*4 function (far external)
SYNTAX: FI=FGQ1(F,A,B)
INPUT: A,B (REAL*4) interval over which to integrate
F (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence FX=F(X)
OUTPUT: the integral
NOTE: your function will be integrated from A to B
for double precision use FGQ1D
20-point Gauss quadrature is used (96-point for double
precision)


NAME: FGQ2
PURPOSE: numerical integration over definite interval in 2-D
TYPE: REAL*4 function (far external)
SYNTAX: FI=FGQ2(F,FY1,FY2,A,B)
INPUT: A,B (REAL*4) interval over which to integrate F
F (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence FXY=F(X,Y)
FY1 (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence Y1=FY1(X)
FY2 (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence Y2=FY2(X)
OUTPUT: the integral
NOTE: your function will be integrated in X from A to B and Y
from FY1(X) to FY2(X), 20*20=400 point Gauss quadrature
is used (96*96=9216 points for double precision)
for double precision use FGQ2D


NAME: FGQ3
PURPOSE: numerical integration over definite interval in 3-D
TYPE: REAL*4 function (far external)
SYNTAX: FI=FGQ3(F,FZ1,FZ2,FY1,FY2,A,B)
INPUT: A,B (REAL*4) interval over which to integrate F
F (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence FXYZ=F(X,Y,Z)
FY1 (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence Y1=FY1(X)
FY2 (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence Y2=FY2(X)
FZ1 (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence Z1=FZ1(X,Y)
FZ2 (REAL*4 function) that YOU MUST SUPPLY and must be
called by the sequence Z2=FZ2(X,Y)
OUTPUT: the integral
NOTE: your function will be integrated in X from A to B and Y
from FY1(X) to FY2(X) and Z from FZ1(X,Y) to FZ2(X,Y)
20*20*20=8000 point Gauss quadrature is used (96*96*96=884736
for double precision)
for double precision use FGQ3D


NAME: FPG
PURPOSE: normal probability distribution in percent
TYPE: REAL*4 function (far external)
SYNTAX: F=FPG(XBAR,SIGMA,X,DX)
INPUT: XBAR (REAL*4) mean
SIGMA (REAL*4) standard deviation
X (REAL*4) independent variable
DX (REAL*4) increment in X (if you want to know the
probability of 0,5,10,15,20,25,...,95,100%, then X=0,5,10,...
and DX=5)
OUTPUT: F (REAL*4) probability in %


NAME: FRF
PURPOSE: cubic error function
TYPE: REAL*4 function (far external)
SYNTAX: F=FRF(X)
INPUT: X (REAL*4)
OUTPUT: F (REAL*4)
NOTE: FRF is similar to ERF and also varies from -1 to 1 as X varies
from -infinity to +infinity, it pops up in some problems like
the error function (e.g. statistical thermodynamics)


NAME: FTC95
PURPOSE: Student's T-distribution for 95% confidence
TYPE: REAL*4 function (far external)
SYNTAX: F=FTC95(N)
INPUT: N (INTEGER*2) number of degrees of freedom
OUTPUT: F (REAL*4)
NOTE: "Student" is just the guy's hokey pseudonym - it doesn't mean
anything


NAME: GAMAL
PURPOSE: natural log of the Gamma function for large values
TYPE: REAL*4 function (far external)
SYNTAX: G=GAMAL(X)
INPUT: X (REAL*4)
OUTPUT: G (REAL*4)


NAME: GAMMA
PURPOSE: Gamma function
TYPE: REAL*4 function (far external)
SYNTAX: G=GAMMA(X)
INPUT: X (REAL*4)
OUTPUT: G (REAL*4)


NAME: GXNYM
PURPOSE: numerical integration of X**N*Y**M*dXdY over polygonal region
TYPE: REAL*4 function (far external)
SYNTAX: G=GXNYM(X,Y,N,M,L)
INPUT: X,Y (REAL*4) the points defining the boundary of a polygon
N (INTEGER*2) the exponent on X (may be -+0)
M (INTEGER*2) the exponent on Y (may be -+0)
L (INTEGER*2) the number of points
OUTPUT: G (REAL*4)
NOTE: 8-point Gauss quadrature and Green's Lemma are used,
integration will be exact (machine precision) for N+M<16.
If N=M=0 then you get the area and you should use APOLY.
To get the location of the centroid and the moment of inertia
use the following

XC=GXNYM(X,Y,1,0,L)/GXNYM(X,Y,0,0,L)
YC=GXNYM(X,Y,0,1,L)/GXNYM(X,Y,0,0,L)
AI=GXNYM(X,Y,1,1,L)

You can get radii of gyration and other useful things like FEM
coefficients from GXNYM.


NAME: IRAND
PURPOSE: bounded random integer
TYPE: INTEGER*2 function (far external)
SYNTAX: I=IRAND(MIN,MAX)
INPUT: MIN (INTEGER*2) lower limit on I
MAX (INTEGER*2) upper limit on I


NAME: PLG0
PURPOSE: Legendre polynomial of N-th degree
TYPE: REAL*4 function (far external)
SYNTAX: P=PLG0(N,X)
INPUT: N (INTEGER*2) degree
X (REAL*4)
OUTPUT: P (REAL*4)


NAME: PLG1
PURPOSE: Legendre polynomial of N-th degree (first derivative)
TYPE: REAL*4 function (far external)
SYNTAX: P=PLG1(N,X)
INPUT: N (INTEGER*2) degree
X (REAL*4)
OUTPUT: P (REAL*4)


NAME: PLG2
PURPOSE: Legendre polynomial of N-th degree (second derivative)
TYPE: REAL*4 function (far external)
SYNTAX: P=PLG2(N,X)
INPUT: N (INTEGER*2) degree
X (REAL*4)
OUTPUT: P (REAL*4)


NAME: PLG3
PURPOSE: Legendre polynomial of N-th degree (third derivative)
TYPE: REAL*4 function (far external)
SYNTAX: P=PLG3(N,X)
INPUT: N (INTEGER*2) degree
X (REAL*4)
OUTPUT: P (REAL*4)


NAME: PPLG0
PURPOSE: Legendre polynomial of N-th degree (2 dimensions)
TYPE: REAL*4 function (far external)
SYNTAX: P=PPLG0(N,X,Y)
INPUT: N (INTEGER*2) degree
X,Y (REAL*4)
OUTPUT: P (REAL*4)


NAME: RPQ
PURPOSE: rational polynomial evaluation
TYPE: REAL*4 function (far external)
SYNTAX: R=RPQ(P,N,Q,M,X)
INPUT: P (REAL*4) coefficients in numerator polynomial
N (INTEGER*2) number of terms in P
Q (REAL*4) coefficients in denominator polynomial
M (INTEGER*2) number of terms in Q
X (REAL*4)
OUTPUT: R (REAL*4)
NOTE: RPQ evaluates a rational polynomial as shown below using
Horner's method

R=(P1+P2*X+P3*X**2+P4*X**3+...)/(Q1+Q2*X+Q3*X**2+Q4*X**3...)

for double precision use RPQD and make sure that you declare
R,P,Q,RPQD all to be REAL*8


NAME: SEVAL
PURPOSE: cubic spline evaluation
TYPE: REAL*4 function (far external)
SYNTAX: Y=SEVAL(XI,YI,N,C,X)
INPUT: XI,YI (REAL*4) specified points
N (INTEGER*2) number of points
C (REAL*4) coefficients determined by first calling SPLNE
X (REAL*4) point where you want to interpolate
OUTPUT: Y (REAL*4) interpolated value
NOTE: you need to first call SPLNE, you only need to do this once


NAME: XRAND
PURPOSE: normally distributed random number
TYPE: REAL*4 function (far external)
SYNTAX: X=XRAND(STD,BAR)
INPUT: STD (REAL*4) standard deviation of X
BAR (REAL*4) average X
X (REAL*4)