home *** CD-ROM | disk | FTP | other *** search
/ PC World Plus! (NZ) 2001 June / HDC50.iso / Runimage / Delphi50 / Doc / MATH.INT < prev    next >
Encoding:
Text File  |  1999-08-11  |  10.6 KB  |  257 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Borland Delphi Runtime Library                  }
  5. {       Math Unit                                       }
  6. {                                                       }
  7. {       Copyright (C) 1996,99 Inprise Corporation       }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit Math;
  12.  
  13. { This unit contains high-performance arithmetic, trigonometric, logorithmic,
  14.   statistical and financial calculation routines which supplement the math
  15.   routines that are part of the Delphi language or System unit. }
  16.  
  17. {$N+,S-}
  18.  
  19. interface
  20.  
  21. uses SysUtils;
  22.  
  23. const   { Ranges of the IEEE floating point types, including denormals }
  24.   MinSingle        =     1.5e-45;
  25.   MaxSingle        =     3.4e+38;
  26.   MinDouble        =     5.0e-324;
  27.   MaxDouble        =     1.7e+308;
  28.   MinExtended      =     3.4e-4932;
  29.   MaxExtended      =     1.1e+4932;
  30.   MinComp          =     -9.223372036854775807e+18;
  31.   MaxComp          =     9.223372036854775807e+18;
  32.  
  33. {-----------------------------------------------------------------------
  34. References:
  35.  
  36. 1) P.J. Plauger, "The Standard C Library", Prentice-Hall, 1992, Ch. 7.
  37. 2) W.J. Cody, Jr., and W. Waite, "Software Manual For the Elementary
  38.    Functions", Prentice-Hall, 1980.
  39. 3) Namir Shammas, "C/C++ Mathematical Algorithms for Scientists and Engineers",
  40.    McGraw-Hill, 1995, Ch 8.
  41. 4) H.T. Lau, "A Numerical Library in C for Scientists and Engineers",
  42.    CRC Press, 1994, Ch. 6.
  43. 5) "Pentium(tm) Processor User's Manual, Volume 3: Architecture
  44.    and Programming Manual", Intel, 1994
  45.  
  46. All angle parameters and results of trig functions are in radians.
  47.  
  48. Most of the following trig and log routines map directly to Intel 80387 FPU
  49. floating point machine instructions.  Input domains, output ranges, and
  50. error handling are determined largely by the FPU hardware.
  51. Routines coded in assembler favor the Pentium FPU pipeline architecture.
  52. -----------------------------------------------------------------------}
  53.  
  54. { Trigonometric functions }
  55. function ArcCos(X: Extended): Extended;  { IN: |X| <= 1  OUT: [0..PI] radians }
  56. function ArcSin(X: Extended): Extended;  { IN: |X| <= 1  OUT: [-PI/2..PI/2] radians }
  57.  
  58. { ArcTan2 calculates ArcTan(Y/X), and returns an angle in the correct quadrant.
  59.   IN: |Y| < 2^64, |X| < 2^64, X <> 0   OUT: [-PI..PI] radians }
  60. function ArcTan2(Y, X: Extended): Extended;
  61.  
  62. { SinCos is 2x faster than calling Sin and Cos separately for the same angle }
  63. procedure SinCos(Theta: Extended; var Sin, Cos: Extended) register;
  64. function Tan(X: Extended): Extended;
  65. function Cotan(X: Extended): Extended;           { 1 / tan(X), X <> 0 }
  66. function Hypot(X, Y: Extended): Extended;        { Sqrt(X**2 + Y**2) }
  67.  
  68. { Angle unit conversion routines }
  69. function DegToRad(Degrees: Extended): Extended;  { Radians := Degrees * PI / 180}
  70. function RadToDeg(Radians: Extended): Extended;  { Degrees := Radians * 180 / PI }
  71. function GradToRad(Grads: Extended): Extended;   { Radians := Grads * PI / 200 }
  72. function RadToGrad(Radians: Extended): Extended; { Grads := Radians * 200 / PI }
  73. function CycleToRad(Cycles: Extended): Extended; { Radians := Cycles * 2PI }
  74. function RadToCycle(Radians: Extended): Extended;{ Cycles := Radians / 2PI }
  75.  
  76. { Hyperbolic functions and inverses }
  77. function Cosh(X: Extended): Extended;
  78. function Sinh(X: Extended): Extended;
  79. function Tanh(X: Extended): Extended;
  80. function ArcCosh(X: Extended): Extended;   { IN: X >= 1 }
  81. function ArcSinh(X: Extended): Extended;
  82. function ArcTanh(X: Extended): Extended;   { IN: |X| <= 1 }
  83.  
  84. { Logorithmic functions }
  85. function LnXP1(X: Extended): Extended;   { Ln(X + 1), accurate for X near zero }
  86. function Log10(X: Extended): Extended;                     { Log base 10 of X}
  87. function Log2(X: Extended): Extended;                      { Log base 2 of X }
  88. function LogN(Base, X: Extended): Extended;                { Log base N of X }
  89.  
  90. { Exponential functions }
  91.  
  92. { IntPower: Raise base to an integral power.  Fast. }
  93. function IntPower(Base: Extended; Exponent: Integer): Extended register;
  94.  
  95. { Power: Raise base to any power.
  96.   For fractional exponents, or |exponents| > MaxInt, base must be > 0. }
  97. function Power(Base, Exponent: Extended): Extended;
  98.  
  99.  
  100. { Miscellaneous Routines }
  101.  
  102. { Frexp:  Separates the mantissa and exponent of X. }
  103. procedure Frexp(X: Extended; var Mantissa: Extended; var Exponent: Integer) register;
  104.  
  105. { Ldexp: returns X*2**P }
  106. function Ldexp(X: Extended; P: Integer): Extended register;
  107.  
  108. { Ceil: Smallest integer >= X, |X| < MaxInt }
  109. function Ceil(X: Extended):Integer;
  110.  
  111. { Floor: Largest integer <= X,  |X| < MaxInt }
  112. function Floor(X: Extended): Integer;
  113.  
  114. { Poly: Evaluates a uniform polynomial of one variable at value X.
  115.     The coefficients are ordered in increasing powers of X:
  116.     Coefficients[0] + Coefficients[1]*X + ... + Coefficients[N]*(X**N) }
  117. function Poly(X: Extended; const Coefficients: array of Double): Extended;
  118.  
  119. {-----------------------------------------------------------------------
  120. Statistical functions.
  121.  
  122. Common commercial spreadsheet macro names for these statistical and
  123. financial functions are given in the comments preceding each function.
  124. -----------------------------------------------------------------------}
  125.  
  126. { Mean:  Arithmetic average of values.  (AVG):  SUM / N }
  127. function Mean(const Data: array of Double): Extended;
  128.  
  129. { Sum: Sum of values.  (SUM) }
  130. function Sum(const Data: array of Double): Extended register;
  131. function SumInt(const Data: array of Integer): Integer register;
  132. function SumOfSquares(const Data: array of Double): Extended;
  133. procedure SumsAndSquares(const Data: array of Double;
  134.   var Sum, SumOfSquares: Extended) register;
  135.  
  136. { MinValue: Returns the smallest signed value in the data array (MIN) }
  137. function MinValue(const Data: array of Double): Double;
  138. function MinIntValue(const Data: array of Integer): Integer;
  139.  
  140. function Min(A,B: Integer): Integer; overload;
  141. function Min(A,B: Int64): Int64; overload;
  142. function Min(A,B: Single): Single; overload;
  143. function Min(A,B: Double): Double; overload;
  144. function Min(A,B: Extended): Extended; overload;
  145.  
  146. { MaxValue: Returns the largest signed value in the data array (MAX) }
  147. function MaxValue(const Data: array of Double): Double;
  148. function MaxIntValue(const Data: array of Integer): Integer;
  149.  
  150. function Max(A,B: Integer): Integer; overload;
  151. function Max(A,B: Int64): Int64; overload;
  152. function Max(A,B: Single): Single; overload;
  153. function Max(A,B: Double): Double; overload;
  154. function Max(A,B: Extended): Extended; overload;
  155.  
  156. { Standard Deviation (STD): Sqrt(Variance). aka Sample Standard Deviation }
  157. function StdDev(const Data: array of Double): Extended;
  158.  
  159. { MeanAndStdDev calculates Mean and StdDev in one call. }
  160. procedure MeanAndStdDev(const Data: array of Double; var Mean, StdDev: Extended);
  161.  
  162. { Population Standard Deviation (STDP): Sqrt(PopnVariance).
  163.   Used in some business and financial calculations. }
  164. function PopnStdDev(const Data: array of Double): Extended;
  165.  
  166. { Variance (VARS): TotalVariance / (N-1). aka Sample Variance }
  167. function Variance(const Data: array of Double): Extended;
  168.  
  169. { Population Variance (VAR or VARP): TotalVariance/ N }
  170. function PopnVariance(const Data: array of Double): Extended;
  171.  
  172. { Total Variance: SUM(i=1,N)[(X(i) - Mean)**2] }
  173. function TotalVariance(const Data: array of Double): Extended;
  174.  
  175. { Norm:  The Euclidean L2-norm.  Sqrt(SumOfSquares) }
  176. function Norm(const Data: array of Double): Extended;
  177.  
  178. { MomentSkewKurtosis: Calculates the core factors of statistical analysis:
  179.   the first four moments plus the coefficients of skewness and kurtosis.
  180.   M1 is the Mean.  M2 is the Variance.
  181.   Skew reflects symmetry of distribution: M3 / (M2**(3/2))
  182.   Kurtosis reflects flatness of distribution: M4 / Sqr(M2) }
  183. procedure MomentSkewKurtosis(const Data: array of Double;
  184.   var M1, M2, M3, M4, Skew, Kurtosis: Extended);
  185.  
  186. { RandG produces random numbers with Gaussian distribution about the mean.
  187.   Useful for simulating data with sampling errors. }
  188. function RandG(Mean, StdDev: Extended): Extended;
  189.  
  190. {-----------------------------------------------------------------------
  191. Financial functions.  Standard set from Quattro Pro.
  192.  
  193. Parameter conventions:
  194.  
  195. From the point of view of A, amounts received by A are positive and
  196. amounts disbursed by A are negative (e.g. a borrower's loan repayments
  197. are regarded by the borrower as negative).
  198.  
  199. Interest rates are per payment period.  11% annual percentage rate on a
  200. loan with 12 payments per year would be (11 / 100) / 12 = 0.00916667
  201.  
  202. -----------------------------------------------------------------------}
  203.  
  204. type
  205.   TPaymentTime = (ptEndOfPeriod, ptStartOfPeriod);
  206.  
  207. { Double Declining Balance (DDB) }
  208. function DoubleDecliningBalance(Cost, Salvage: Extended;
  209.   Life, Period: Integer): Extended;
  210.  
  211. { Future Value (FVAL) }
  212. function FutureValue(Rate: Extended; NPeriods: Integer; Payment, PresentValue:
  213.   Extended; PaymentTime: TPaymentTime): Extended;
  214.  
  215. { Interest Payment (IPAYMT)  }
  216. function InterestPayment(Rate: Extended; Period, NPeriods: Integer; PresentValue,
  217.   FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
  218.  
  219. { Interest Rate (IRATE) }
  220. function InterestRate(NPeriods: Integer;
  221.   Payment, PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
  222.  
  223. { Internal Rate of Return. (IRR) Needs array of cash flows. }
  224. function InternalRateOfReturn(Guess: Extended;
  225.   const CashFlows: array of Double): Extended;
  226.  
  227. { Number of Periods (NPER) }
  228. function NumberOfPeriods(Rate, Payment, PresentValue, FutureValue: Extended;
  229.   PaymentTime: TPaymentTime): Extended;
  230.  
  231. { Net Present Value. (NPV) Needs array of cash flows. }
  232. function NetPresentValue(Rate: Extended; const CashFlows: array of Double;
  233.   PaymentTime: TPaymentTime): Extended;
  234.  
  235. { Payment (PAYMT) }
  236. function Payment(Rate: Extended; NPeriods: Integer;
  237.   PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
  238.  
  239. { Period Payment (PPAYMT) }
  240. function PeriodPayment(Rate: Extended; Period, NPeriods: Integer;
  241.   PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
  242.  
  243. { Present Value (PVAL) }
  244. function PresentValue(Rate: Extended; NPeriods: Integer;
  245.   Payment, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
  246.  
  247. { Straight Line depreciation (SLN) }
  248. function SLNDepreciation(Cost, Salvage: Extended; Life: Integer): Extended;
  249.  
  250. { Sum-of-Years-Digits depreciation (SYD) }
  251. function SYDDepreciation(Cost, Salvage: Extended; Life, Period: Integer): Extended;
  252.  
  253. type
  254.   EInvalidArgument = class(EMathError) end;
  255.  
  256. implementation
  257.