|
a |
|
b/LMathLib.def |
|
|
1 |
DEFINITION MODULE LMathLib;
|
|
|
2 |
|
|
|
3 |
(*------------------------------------------------------------------------*)
|
|
|
4 |
(* Stellt verschiedene mathematische Funktionen zur Verf"ugung *)
|
|
|
5 |
(* Provides different mathematical funktiones *)
|
|
|
6 |
(* *)
|
|
|
7 |
(* Konstanten zum Teil aus: *)
|
|
|
8 |
(* *)
|
|
|
9 |
(* Computer Approximations *)
|
|
|
10 |
(* Hart, Cheney, e.a. *)
|
|
|
11 |
(* The SIAM Series in Applied Mathematics *)
|
|
|
12 |
(* John Wiley & Sons, INC. New York London Sydney, 1968 *)
|
|
|
13 |
(*------------------------------------------------------------------------*)
|
|
|
14 |
(* Implementation : Michael Riedl *)
|
|
|
15 |
(* Licence : GNU Lesser General Public License (LGPL) *)
|
|
|
16 |
(*------------------------------------------------------------------------*)
|
|
|
17 |
|
|
|
18 |
(* $Id: LMathLib.def,v 1.11 2018/03/11 11:19:56 mriedl Exp mriedl $ *)
|
|
|
19 |
|
|
|
20 |
IMPORT IEEE;
|
|
|
21 |
|
|
|
22 |
CONST C = 0.57721566490153286060651209008240243; (* Eulerkonstante. *)
|
|
|
23 |
sqrtpi = 1.772453850905516027298167483341145; (* \sqrt{\pi} *)
|
|
|
24 |
rezsqrtpi = 0.564189583547756286948079451560773; (* \sqrt{1\over\pi} *)
|
|
|
25 |
sqrt2 = 1.41421356237309504880168872420969808; (* 2^(1/2) *)
|
|
|
26 |
sqrt05 = 0.70710678118654752440084436210484904; (* 2^(1/2)/2 *)
|
|
|
27 |
sqrt3 = 1.73205080756887729352744634150587237; (* 3^(1/2) *)
|
|
|
28 |
sqrt5 = 2.23606797749978969640917366873127624;
|
|
|
29 |
|
|
|
30 |
CONST pi = 3.14159265358979323846264338327950288;
|
|
|
31 |
twopi = 6.28318530717958647692528676655900576; (* 2 \pi *)
|
|
|
32 |
halfpi = 1.57079632679489661923132169163975144; (* \pi \over 2 *)
|
|
|
33 |
quartpi = 0.78539816339744830961566084581987572; (* \pi \over 4 *)
|
|
|
34 |
sqrt2pi = 2.50662827463100050241576528481105; (* \sqrt{2\pi} *)
|
|
|
35 |
lnpi = 1.144729885849400174143427351353059; (* ln(pi) *)
|
|
|
36 |
sqrtpi05 = 0.88622693778351338858761284182448424; (* 0.5*sqrt(pi) *)
|
|
|
37 |
e = 2.71828182845904523536028747135266250;
|
|
|
38 |
ln10 = 2.30258509299404568401799145468436421;
|
|
|
39 |
ln2 = 0.69314718055994530941723212145817657;
|
|
|
40 |
log2e = 1.44269504088896340735992468100189213; (* log2(e) *)
|
|
|
41 |
|
|
|
42 |
GoldSec = (1.0 + sqrt5) / 2.0; (* Goldener Schnitt, gold section *)
|
|
|
43 |
CGold = 2.0 - GoldSec; (* (3 - sqrt(5))/2 = 0,381966... *)
|
|
|
44 |
|
|
|
45 |
CONST MachEpsR8 = 2.22044604925031308E-16;
|
|
|
46 |
MachEpsR4 = 1.192092895507813E-07; (* 2^(-23) *)
|
|
|
47 |
MachEps = MachEpsR8;
|
|
|
48 |
Small = 1.0 / VAL(LONGREAL,MAX(REAL));
|
|
|
49 |
MinReal8 = 2.225073858507202E-308; (* 2^(-1022) *)
|
|
|
50 |
MinReal4 = 1.175494350822288E-38; (* 2^(-126) *)
|
|
|
51 |
MaxLog = 709.7827128933840; (* Max. argument for Exp = Ln(MaxNum) *)
|
|
|
52 |
MinLog = -708.3964185322641; (* Min. argument for Exp = Ln(MinNum) *)
|
|
|
53 |
MinExp = -745.1332191019417; (* Number for which exp(MinExp) = 0 *)
|
|
|
54 |
MaxFac = 170; (* Max. argument for Factorial *)
|
|
|
55 |
|
|
|
56 |
(*
|
|
|
57 |
* CONST NAN = IEEE.NAN;
|
|
|
58 |
* INF = IEEE.INF;
|
|
|
59 |
*)
|
|
|
60 |
|
|
|
61 |
VAR INF : LONGREAL;
|
|
|
62 |
NAN : LONGREAL;
|
|
|
63 |
|
|
|
64 |
(*------------------------------------------------------------------------*)
|
|
|
65 |
(* Funktion1 und FunktionN werden in Ausgleich & SpezFunk1 genutzt und *)
|
|
|
66 |
(* hier an zentraler Stelle definiert *)
|
|
|
67 |
(*------------------------------------------------------------------------*)
|
|
|
68 |
|
|
|
69 |
TYPE Funktion1 = PROCEDURE(LONGREAL) : LONGREAL;
|
|
|
70 |
FunktionN = PROCEDURE(VAR ARRAY OF LONGREAL,
|
|
|
71 |
CARDINAL) : LONGREAL;
|
|
|
72 |
|
|
|
73 |
(*--------------------------------------------------------------------------*)
|
|
|
74 |
|
|
|
75 |
PROCEDURE sqr(x : LONGREAL) : LONGREAL;
|
|
|
76 |
|
|
|
77 |
(*----------------------------------------------------------------*)
|
|
|
78 |
(* Analog zu Pascal sqr *)
|
|
|
79 |
(*----------------------------------------------------------------*)
|
|
|
80 |
|
|
|
81 |
PROCEDURE Rest(x : LONGREAL) : LONGREAL;
|
|
|
82 |
|
|
|
83 |
(*----------------------------------------------------------------*)
|
|
|
84 |
(* Berechet die Nachkommastellen von x *)
|
|
|
85 |
(*----------------------------------------------------------------*)
|
|
|
86 |
|
|
|
87 |
PROCEDURE ceil(X : LONGREAL) : INTEGER;
|
|
|
88 |
|
|
|
89 |
(*----------------------------------------------------------------*)
|
|
|
90 |
(* Kleinsten ganzzahligen Wert, der nicht kleiner als x ist. *)
|
|
|
91 |
(* Bei negativen Zahlen werden also nur die Nachkommastellen *)
|
|
|
92 |
(* abgeschnitten, bei positiven Zahlen wird auf die naechst- *)
|
|
|
93 |
(* groessere ganze Zahl aufgerundet. Entspricht Rundung gegen *)
|
|
|
94 |
(* Plus Unendlich (Aufrundungsfunktion). *)
|
|
|
95 |
(* *)
|
|
|
96 |
(* Returns the least integer greater than or equal to X. *)
|
|
|
97 |
(* *)
|
|
|
98 |
(* Beispiele / examples: *)
|
|
|
99 |
(* *)
|
|
|
100 |
(* ceil(-1.5) = -1.0, ceil(1.5) = 2.0 *)
|
|
|
101 |
(* ceil(-1.0) = -1.0, ceil(1.0) = 1.0 *)
|
|
|
102 |
(*----------------------------------------------------------------*)
|
|
|
103 |
|
|
|
104 |
PROCEDURE entier(X : LONGREAL) : INTEGER;
|
|
|
105 |
|
|
|
106 |
(*----------------------------------------------------------------*)
|
|
|
107 |
(* Groessten ganzzahligen Wert, der nicht groesser als X ist. *)
|
|
|
108 |
(* Bei negativen Zahlen wird also auf die naechstkleinere ganze *)
|
|
|
109 |
(* Zahl abgerundet, bei positiven Zahlen werden nur die Nach- *)
|
|
|
110 |
(* kommastellen abgeschnitten. Entspricht Rundung gegen Minus *)
|
|
|
111 |
(* Unendlich (Abrundungsfunktion). *)
|
|
|
112 |
(* *)
|
|
|
113 |
(* Returns the largest integer not grater than the value of X *)
|
|
|
114 |
(* ('rounding toward zero'). In other languages this is referred *)
|
|
|
115 |
(* to as the floor function. *)
|
|
|
116 |
(* *)
|
|
|
117 |
(* X - 1 < entier(X) <= X *)
|
|
|
118 |
(* *)
|
|
|
119 |
(* Beispiele / examples: *)
|
|
|
120 |
(* *)
|
|
|
121 |
(* entier(-1.5) = -2.0, entier(1.5) = 1.0 *)
|
|
|
122 |
(* entier(-1.0) = -1.0, entier(1.0) = 1.0 *)
|
|
|
123 |
(* *)
|
|
|
124 |
(* This function is equal to the entier function defined in the *)
|
|
|
125 |
(* "Revised report on the algorithmic language Algol 60", *)
|
|
|
126 |
(* sec. 3.2.5. *)
|
|
|
127 |
(*----------------------------------------------------------------*)
|
|
|
128 |
|
|
|
129 |
PROCEDURE CardPot(x : LONGREAL;
|
|
|
130 |
i : CARDINAL) : LONGREAL;
|
|
|
131 |
|
|
|
132 |
(*----------------------------------------------------------------*)
|
|
|
133 |
(* Berechet i-te Potenz von x / x to the power of i *)
|
|
|
134 |
(*----------------------------------------------------------------*)
|
|
|
135 |
|
|
|
136 |
PROCEDURE IntPow(x : LONGREAL;
|
|
|
137 |
i : INTEGER) : LONGREAL;
|
|
|
138 |
|
|
|
139 |
(*----------------------------------------------------------------*)
|
|
|
140 |
(* Berechet i-te Potenz von x / x to the integer power of i *)
|
|
|
141 |
(*----------------------------------------------------------------*)
|
|
|
142 |
|
|
|
143 |
PROCEDURE Pow10(pot : INTEGER) : LONGREAL;
|
|
|
144 |
|
|
|
145 |
(*----------------------------------------------------------------*)
|
|
|
146 |
(* Berechnet $ 10^{pot} $ = 10**pot / power of 10**pot *)
|
|
|
147 |
(*----------------------------------------------------------------*)
|
|
|
148 |
|
|
|
149 |
PROCEDURE log10(x : LONGREAL) : LONGREAL;
|
|
|
150 |
|
|
|
151 |
(*----------------------------------------------------------------*)
|
|
|
152 |
(* Berechnet den dekadischen Logaritmus von x (ln base 10 of x) *)
|
|
|
153 |
(* Calculates the logarithm of x to the base of 10 *)
|
|
|
154 |
(*----------------------------------------------------------------*)
|
|
|
155 |
|
|
|
156 |
PROCEDURE Pow2(pow : CARDINAL) : CARDINAL;
|
|
|
157 |
|
|
|
158 |
(*----------------------------------------------------------------*)
|
|
|
159 |
(* Berechnet die "pow"-sche Potenz von 2 = 2**pow *)
|
|
|
160 |
(* Two to the power of "pow" *)
|
|
|
161 |
(*----------------------------------------------------------------*)
|
|
|
162 |
|
|
|
163 |
PROCEDURE Log2(N : CARDINAL) : CARDINAL;
|
|
|
164 |
|
|
|
165 |
(*----------------------------------------------------------------*)
|
|
|
166 |
(* Logarithm to base 2 (rounded down to the next-lower integral *)
|
|
|
167 |
(* value, in case N is not a power of 2.) The result is in the *)
|
|
|
168 |
(* range 0..31. *)
|
|
|
169 |
(* *)
|
|
|
170 |
(* This code is from Peter Moylan *)
|
|
|
171 |
(*----------------------------------------------------------------*)
|
|
|
172 |
|
|
|
173 |
PROCEDURE arctan2(x,y : LONGREAL) : LONGREAL;
|
|
|
174 |
|
|
|
175 |
(*----------------------------------------------------------------*)
|
|
|
176 |
(* Berechnet den Arcus Tangens von x / y. *)
|
|
|
177 |
(* *)
|
|
|
178 |
(* Das Ergebnis liegt im Interval [-pi,pii] und ist, je nach *)
|
|
|
179 |
(* nach Quadrant, vorzeichenbehaftet. *)
|
|
|
180 |
(* *)
|
|
|
181 |
(* Inverse tangent of x / y. Result is in range -pi to pi. *)
|
|
|
182 |
(*----------------------------------------------------------------*)
|
|
|
183 |
|
|
|
184 |
PROCEDURE sinh(x : LONGREAL) : LONGREAL;
|
|
|
185 |
|
|
|
186 |
(*----------------------------------------------------------------*)
|
|
|
187 |
(* Berechnet den Sinushyperbolikus von x im ersten und vierten *)
|
|
|
188 |
(* Quadranten, je nach Vorzeichen von x *)
|
|
|
189 |
(*----------------------------------------------------------------*)
|
|
|
190 |
|
|
|
191 |
PROCEDURE cosh(x : LONGREAL) : LONGREAL;
|
|
|
192 |
|
|
|
193 |
(*----------------------------------------------------------------*)
|
|
|
194 |
(* Berechnet den Cosinushyperbolikus von x *)
|
|
|
195 |
(*----------------------------------------------------------------*)
|
|
|
196 |
|
|
|
197 |
PROCEDURE tanh(x : LONGREAL) : LONGREAL;
|
|
|
198 |
|
|
|
199 |
(*----------------------------------------------------------------*)
|
|
|
200 |
(* Berechnet den Tangenshyperbolikus von x *)
|
|
|
201 |
(*----------------------------------------------------------------*)
|
|
|
202 |
|
|
|
203 |
PROCEDURE arcosh(x : LONGREAL) : LONGREAL;
|
|
|
204 |
|
|
|
205 |
(*----------------------------------------------------------------*)
|
|
|
206 |
(* Berechnet den Areacosinushyperbolikus von x *)
|
|
|
207 |
(*----------------------------------------------------------------*)
|
|
|
208 |
|
|
|
209 |
PROCEDURE arsinh(x : LONGREAL) : LONGREAL;
|
|
|
210 |
|
|
|
211 |
(*----------------------------------------------------------------*)
|
|
|
212 |
(* Berechnet den Areasinushyperbolikus von x *)
|
|
|
213 |
(*----------------------------------------------------------------*)
|
|
|
214 |
|
|
|
215 |
PROCEDURE artanh(x : LONGREAL) : LONGREAL;
|
|
|
216 |
|
|
|
217 |
(*----------------------------------------------------------------*)
|
|
|
218 |
(* Berechnet den Areatangenshyperbolikus von x *)
|
|
|
219 |
(*----------------------------------------------------------------*)
|
|
|
220 |
|
|
|
221 |
PROCEDURE MinCard(i,j : CARDINAL) : CARDINAL;
|
|
|
222 |
|
|
|
223 |
(*----------------------------------------------------------------*)
|
|
|
224 |
(* Minimum von i und j *)
|
|
|
225 |
(*----------------------------------------------------------------*)
|
|
|
226 |
|
|
|
227 |
PROCEDURE MaxCard(i,j : CARDINAL) : CARDINAL;
|
|
|
228 |
|
|
|
229 |
(*----------------------------------------------------------------*)
|
|
|
230 |
(* Maximum von i und j *)
|
|
|
231 |
(*----------------------------------------------------------------*)
|
|
|
232 |
|
|
|
233 |
PROCEDURE MinInt(i,j : INTEGER) : INTEGER;
|
|
|
234 |
|
|
|
235 |
(*----------------------------------------------------------------*)
|
|
|
236 |
(* Minimum von i und j *)
|
|
|
237 |
(*----------------------------------------------------------------*)
|
|
|
238 |
|
|
|
239 |
PROCEDURE MaxInt(i,j : INTEGER) : INTEGER;
|
|
|
240 |
|
|
|
241 |
(*----------------------------------------------------------------*)
|
|
|
242 |
(* Maximum von i und j *)
|
|
|
243 |
(*----------------------------------------------------------------*)
|
|
|
244 |
|
|
|
245 |
PROCEDURE Sign(x: LONGREAL): LONGREAL;
|
|
|
246 |
|
|
|
247 |
(*----------------------------------------------------------------*)
|
|
|
248 |
(* Entsprechung der FORTRAN SIGN-Funktion *)
|
|
|
249 |
(*----------------------------------------------------------------*)
|
|
|
250 |
|
|
|
251 |
PROCEDURE sign2(a,b : LONGREAL) : LONGREAL;
|
|
|
252 |
|
|
|
253 |
(*----------------------------------------------------------------*)
|
|
|
254 |
(* Gibt a mit dem Vorzeichen von b zurueck. *)
|
|
|
255 |
(* Entspricht FORTRAN SIGN(a,b) *)
|
|
|
256 |
(* *)
|
|
|
257 |
(* Returns a with the sign of b *)
|
|
|
258 |
(*----------------------------------------------------------------*)
|
|
|
259 |
|
|
|
260 |
PROCEDURE fact(n : CARDINAL) : LONGREAL;
|
|
|
261 |
|
|
|
262 |
(*----------------------------------------------------------------*)
|
|
|
263 |
(* Berechet die Fakult"at x! von x, n \in [0..MaxFac] *)
|
|
|
264 |
(*----------------------------------------------------------------*)
|
|
|
265 |
|
|
|
266 |
PROCEDURE BinKoeff(i,j : CARDINAL) : LONGREAL;
|
|
|
267 |
|
|
|
268 |
(*----------------------------------------------------------------*)
|
|
|
269 |
(* Berechnet i "uber j *)
|
|
|
270 |
(*----------------------------------------------------------------*)
|
|
|
271 |
|
|
|
272 |
PROCEDURE Exp(x : LONGREAL) : LONGREAL;
|
|
|
273 |
|
|
|
274 |
(*----------------------------------------------------------------*)
|
|
|
275 |
(* Nur zu Testzecken exp(x) *)
|
|
|
276 |
(*----------------------------------------------------------------*)
|
|
|
277 |
|
|
|
278 |
PROCEDURE ExpM1(x : LONGREAL) : LONGREAL;
|
|
|
279 |
|
|
|
280 |
(*----------------------------------------------------------------*)
|
|
|
281 |
(* Berechnet exp(x) - 1.0 f"ur sehr kleine x *)
|
|
|
282 |
(*----------------------------------------------------------------*)
|
|
|
283 |
|
|
|
284 |
PROCEDURE Pythag(a,b : LONGREAL) : LONGREAL;
|
|
|
285 |
|
|
|
286 |
(*---------------------------------------------------------------*)
|
|
|
287 |
(* Finds sqrt(a**2 + b**2) without overflow or destructive *)
|
|
|
288 |
(* underflow *)
|
|
|
289 |
(* *)
|
|
|
290 |
(* Modula-2 version of Eispack pythag subroutine *)
|
|
|
291 |
(*---------------------------------------------------------------*)
|
|
|
292 |
|
|
|
293 |
PROCEDURE gcd(m,n : INTEGER) : INTEGER;
|
|
|
294 |
|
|
|
295 |
(*---------------------------------------------------------------*)
|
|
|
296 |
(* Iterative Greatest Common Divisor routine *)
|
|
|
297 |
(*---------------------------------------------------------------*)
|
|
|
298 |
|
|
|
299 |
PROCEDURE ggt(n,m : INTEGER) : INTEGER;
|
|
|
300 |
|
|
|
301 |
(*----------------------------------------------------------------*)
|
|
|
302 |
(* Berechnet den gr"o\3ten gemeinsamen Teiler von n und m *)
|
|
|
303 |
(* Greatest common divisor of n and m *)
|
|
|
304 |
(*----------------------------------------------------------------*)
|
|
|
305 |
|
|
|
306 |
PROCEDURE kgv(i,j : INTEGER) : INTEGER;
|
|
|
307 |
|
|
|
308 |
(*----------------------------------------------------------------*)
|
|
|
309 |
(* Berechnet das kleinstes gemeinsame Vielfache von i und j *)
|
|
|
310 |
(* Smallest common multiple of i and j *)
|
|
|
311 |
(*----------------------------------------------------------------*)
|
|
|
312 |
|
|
|
313 |
PROCEDURE RationalApprox( x : LONGREAL;
|
|
|
314 |
N : INTEGER;
|
|
|
315 |
VAR l,r : INTEGER);
|
|
|
316 |
|
|
|
317 |
(*---------------------------------------------------------------*)
|
|
|
318 |
(* Berechnet die rationale Approximation der Zahl x mit l,r < N *)
|
|
|
319 |
(* *)
|
|
|
320 |
(* x = \approx(l / r), l,r <=N *)
|
|
|
321 |
(* *)
|
|
|
322 |
(* Find rational approximation to a given real number x based *)
|
|
|
323 |
(* on the theory of continued fractions *)
|
|
|
324 |
(*---------------------------------------------------------------*)
|
|
|
325 |
|
|
|
326 |
PROCEDURE Faktor( N : INTEGER;
|
|
|
327 |
VAR Faktoren : ARRAY OF INTEGER;
|
|
|
328 |
VAR nFaktor : INTEGER);
|
|
|
329 |
|
|
|
330 |
(*----------------------------------------------------------------*)
|
|
|
331 |
(* Faktorisiert die Zahl N und gibt die Faktoren im Feld Faktoren *)
|
|
|
332 |
(* zurueck so dass gilt N = \PI_{i=0]^{nFaktor-1} Faktoren_i *)
|
|
|
333 |
(* *)
|
|
|
334 |
(* Factors the numner N and returns the factors in array Faktoren *)
|
|
|
335 |
(* such that N = \PI_{i=0]^{nFaktor-1} Faktoren_i *)
|
|
|
336 |
(*----------------------------------------------------------------*)
|
|
|
337 |
|
|
|
338 |
PROCEDURE CalcPrimes(VAR Primes : ARRAY OF CARDINAL;
|
|
|
339 |
N : CARDINAL);
|
|
|
340 |
|
|
|
341 |
(*----------------------------------------------------------------*)
|
|
|
342 |
(* Calculate the first N prime numbers using the algorithm of *)
|
|
|
343 |
(* Eratosthenes. Do not use for large numbers of N. *)
|
|
|
344 |
(*----------------------------------------------------------------*)
|
|
|
345 |
|
|
|
346 |
PROCEDURE CalcMachEps() : LONGREAL;
|
|
|
347 |
|
|
|
348 |
(*----------------------------------------------------------------*)
|
|
|
349 |
(* Berechne d. Maschinengenauigkeit / calculate machine precision *)
|
|
|
350 |
(*----------------------------------------------------------------*)
|
|
|
351 |
|
|
|
352 |
END LMathLib.
|