home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / pascal / mathlib / include / mathlib.ext next >
Encoding:
Text File  |  1994-09-22  |  18.8 KB  |  587 lines
  1. {######################### Bibliothek MATHLIB.    ##########################
  2.  
  3. # Zu deklarierende Datentypen:
  4. type KOOPA=array[0..1,0..2] of real;
  5. type POLYGL=array[0..3,0..1] of real;
  6. type QUASTR=array[0..16] of char;
  7. type REALMAT=array[0..50,0..50] of real;
  8. type REALVEC=array[0..50] of real;
  9. type INTVEC=array[0..50] of integer;
  10. type SCANVEC=array[0..50] of record p:integer;t,x:real end;
  11. type COMPLEX=record re,im:real end;
  12.  
  13. # Für Druckerausgabe Textfile "PRINTER" eroeffnen:
  14. var PRINTER:text;
  15. rewrite(PRINTER,'PRN:');
  16.  
  17. # Zu declarierende Funktionen und Proceduren:
  18. function X(t:real):real;
  19. * Funktionenvektor: f[i]=fi(x)
  20. procedure FUNKVEC(var f:realvec;x:realvec);
  21. * Rechte Seite bei Differentialgleichungen:
  22. procedure F(t:real;x:realvec;var dx:realvec);
  23.  
  24. # Sammlung aller function und procedure aus MATHLIB1:
  25. * Grundsätzliche Bildschirmfunktionen:      }
  26.  
  27. { Bewegt den Cursor eine Zeile nach oben. Kein Effekt in Zeile 0. }
  28. procedure CUR_UP;external;
  29.  
  30. { Bewegt den Cursor eine Zeile nach unten. Kein Effekt in Zeile 24. }
  31. procedure CUR_DOWN;external;
  32.  
  33. { Bewegt den Cursor eine Spalte nach rechts. Kein Effekt in Spalte 79. }
  34. procedure CUR_RIGHT;external;
  35.  
  36. { Bewegt den Cursor eine Spalte nach links. Kein Effekt in Spalte 0. }
  37. procedure CUR_LEFT;external;
  38.  
  39. { Loescht den gesamten Bildschirm und setzt den Cursor in die Ecke (0, 0). }
  40. procedure CLEAR_HOME;external;
  41.  
  42. { Bewegt den Cursor in die linke obere Ecke, identisch mit gotoxy (0, 0). }
  43. procedure CURSOR_HOME;external;
  44.  
  45. { Bewegt den Cursor eine Zeile nach oben. Schiebt den Schirminhalt runter, wenn
  46.   in Zeile 0. }
  47. procedure CUR_UP_SCROLL;external;
  48.  
  49. { Bewegt den Cursor eine Zeile nach unten. Schiebt den Schirminhalt hoch, wenn
  50.   in Zeile 24. }
  51. procedure CUR_DOWN_SCROLL;external;
  52.  
  53. { Loescht von der oberen, linken Ecke bis zum Cursor. }
  54. procedure START_OF_SCREEN;external;
  55.  
  56. { Loescht von der Cursorposition bis zum Ende des Bildschirms. }
  57. procedure END_OF_SCREEN;external;
  58.  
  59. { Loescht die Zeile mit dem Cursor. }
  60. procedure CLEAR_LINE;external;
  61.  
  62. { Loescht vom Anfang der Zeile bis zum Cursor. }
  63. procedure START_OF_LINE;external;
  64.  
  65. { Loescht von der Cursorposition bis zum Ende der Zeile. }
  66. procedure END_OF_LINE;external;
  67.  
  68. { Fuegt eine Zeile vor der aktuellen ein und schiebt die anderen runter. Der
  69.   Cursor steht danach am Anfang der neuen Zeile. }
  70. procedure INSERT_LINE;external;
  71.  
  72. { Loescht die Zeile mit Cursor und schiebt nachfolgende Zeilen hoch. }
  73. procedure DELETE_LINE;external;
  74.  
  75. { Positioniert den Cursor in Spalte 0 <= x <= 79 und Zeile 0 <= y <= 24. }
  76. procedure GOTOXY(x,y:integer);external;
  77.  
  78. { Waehlt die Farbe fuer Schrift aus. Erlaubte Werte bei den Bildschirm-
  79.   Aufloesungen hoch: 0 .. 1; mittel: 0 .. 3; niedrig: 0 .. 15. }
  80. procedure SELECT_COLOR(color:integer);external;
  81.  
  82. { Waehlt die Farbe fuer den Hintergrund. Erlaubte Werte wie bei select_color. }
  83. procedure SELECT_BACKGROUND(color:integer);external;
  84.  
  85. { Der Cursor wird sichtbar. }
  86. procedure CUR_ON;external;
  87.  
  88. { Der Cursor wird unsichtbar. }
  89. procedure CUR_OFF;external;
  90.  
  91. { Die Position des Cursors wird gespeichert. }
  92. procedure SAVE_CURSOR;external;
  93.  
  94. { Der Cursor wird auf die letzte durch save_cursor gespeicherte Position
  95.   gesetzt. }
  96. procedure RESTORE_CURSOR;external;
  97.  
  98. { Schaltet inverse Schrift ein (Farbe von Schrift und Hintergrund getauscht). }
  99. procedure INVERSE_ON;external;
  100.  
  101. { Schaltet inverse Schrift aus. }
  102. procedure INVERSE_OFF;external;
  103.  
  104. { Aktiviert den automatischen Ueberlauf in die naechste Zeile. }
  105. procedure WRAP_ON;external;
  106.  
  107. { Desaktiviert den Ueberlauf. }
  108. procedure WRAP_OFF;external;
  109.  
  110. { Gibt das Zeichen aus und interpretiert dabei keine Control-Codes, sondern
  111.   ersetzt diese durch Grafikzeichen. }
  112. procedure GRAFCHAR(which:char);external;
  113.  
  114. { Setzt Pixel an x,y }
  115. procedure SETXY(x,y:integer);external;
  116.  
  117. { Loescht Pixel an x,y }
  118. procedure RESETXY(x,y:integer);external;
  119.  
  120. { Invertiert Pixel an x,y }
  121. procedure INVSETXY(x,y:integer);external;
  122.  
  123. { Zeichnet Gerade von x1,y1 nach x2,y2 }
  124. procedure GERADE(x1,y1,x2,y2:integer);external;
  125.  
  126. { Loescht Gerade von x1,y1 nach x2,y2 }
  127. procedure LGERADE(x1,y1,x2,y2:integer);external;
  128.  
  129. { Invertiert Gerade von x1,y1 nach x2,y2 }
  130. procedure INVGERADE(x1,y1,x2,y2:integer);external;
  131.  
  132. { Zeichnet horizontale Gerade von x1 nach x2 in y-Hoehe }
  133. procedure HGERADE(x1,y,x2:integer);external;
  134.  
  135. { Loescht horizontale Gerade von x1 nach x2 in y-Hoehe }
  136. procedure LHGERADE(x1,y,x2,:integer);external;
  137.  
  138. { Tastaturabfrage: keine Taste - chr(0), sonst 1. Zeichen aus Puffer }
  139. function GETC:char;external;
  140.  
  141. { Wartet auf Taste, 1. Zeichen aus Puffer }
  142. function WAITC:char;external;
  143.  
  144. { Wartet auf Taste, 1. Zeichen aus Puffer, leert Puffer }
  145. function FIRSTC:char;external;
  146.  
  147. { Wartet auf Taste, letztes Zeichen aus Puffer }
  148. function LASTC:char;external;
  149.  
  150. { wartet auf Tastendruck }
  151. procedure WARTE;external;
  152.  
  153. { erstellt hardcopy }
  154. procedure HARDCOPY;external;
  155.  
  156. { physikalische Bildschirmaddresse }
  157. function PHYSBASE:long_integer;external;
  158.  
  159. { logische Bildschirmaddresse }
  160. function LOGBASE:long_integer;external;
  161.  
  162. { warten auf den naechsten Vertical Blank Interrupt }
  163. procedure VSYNC;external;
  164.  
  165. {# Sammlung von mathematischen Funktionen
  166.  # als Ergaenzung zu den implementierten:}
  167.  
  168. { Vertauschen von a und b }
  169.  
  170. procedure SWAPR(var a,b:real);external;
  171.  
  172. procedure SWAPL(var a,b:long_integer);external;
  173.  
  174. procedure SWAPI(var a,b:integer);external;
  175.  
  176. { Signumsfunktion sgn=0 bei Argument 0 }
  177.  
  178. function ISGN(x:integer):integer;external;
  179.  
  180. function LSGN(x:long_integer):integer;external;
  181.  
  182. function RSGN(x:real):integer;external;
  183.  
  184. { Liefert den Nachkommaanteil }
  185. function FRAC(x:real):real;external;
  186.  
  187. function INTUP(x:real):long_integer;external;
  188.  
  189. function INTDOWN(x:real):long_integer;external;
  190.  
  191. { 10er Logarithmus }
  192. function LOG(x:real):real;external;
  193.  
  194. { Loagrithmus zur Basis a }
  195. function LOGA(b,a:real):real;external;
  196.  
  197. function XHOCH10(x:real):real;external;
  198.  
  199. function AHOCHB(a,b:real):real;external;
  200.  
  201. { ate Wurzel }
  202. function WURZA(b,a:real):real;external;
  203.  
  204. { Grad -> Rad }
  205. function TORAD(grad:real):real;external;
  206.  
  207. { Rad -> Grad }
  208. function TOGRAD(rad:real):real;external;
  209.  
  210. function TAN(x:real):real;external;
  211.  
  212. function SEC(x:real):real;external;
  213.  
  214. function CSC(x:real):real;external;
  215.  
  216. function ARCSIN(x:real):real;external;
  217.  
  218. function ARCCOS(x:real):real;external;
  219.  
  220. function SINH(x:real):real;external;
  221.  
  222. function COSH(x:real):real;external;
  223.  
  224. function TANH(x:real):real;external;
  225.  
  226. function ARCSINH(x:real):real;external;
  227.  
  228. function ARCCOSH(x:real):real;external;
  229.  
  230. function ARCTANH(x:real):real;external;
  231.  
  232. { n-Fakultät }
  233. function FAC(n:integer):real;external;
  234.  
  235. { Binominalkoeffizient }
  236. function BINOM(a,b:real;n:integer):real;external;
  237.  
  238. { Zufallsgenerator: Zahlen zwischen 0 und 1 }
  239. function RANDOM:real;external;
  240.  
  241. {# Soundfunktionen:}
  242.  
  243. procedure SOUND(kanal,periode,laut,centisec:integer);external;
  244.  
  245. procedure SOUNDEIN(kanal,periode,laut:integer);external;
  246.  
  247. procedure SOUNDAUS(kanal:integer);external;
  248.  
  249. {# Umwandlung von Zahlen in ein array of char:}
  250.  
  251. procedure LONGTOSTR(l:long_integer;var c:quastr);external;
  252.  
  253. procedure INTTOSTR(i:integer;var c:quastr);external;
  254.  
  255. procedure REALTOSTR(x:real;s:integer;ex:boolean;var c:quastr);external;
  256.  
  257. {# Einlesen von Zahlen mit festgelegter Anzahl von Ziffern,
  258.  # Fehler werden soweit als moeglich abgefangen:}
  259.  
  260. function ZIFFER(c:char):boolean;external;
  261.  
  262. procedure ELONG(var l:long_integer;stellen:integer);external;
  263.  
  264. procedure EINT(var i:integer;stellen:integer);external;
  265.  
  266. procedure EREAL(var r:real;stellen:integer);external;
  267.  
  268. {# Formatierte Ein/Ausgabe von Vectoren und Matrizen:
  269.  # E=Eingabe, B=Bildschrimausgabe, P=Printerausgabe
  270.  # n:Anzahl der Zeilen oder Vektorelemente
  271.  # m:Anzahl der Spalten
  272.  # chelem:Anzahl der Stellen bei der Ausgabe (mit Vorzeichen,Exponent)
  273.  # vname:Name des Vektors oder der Matrix
  274.  # Textfile PRINTER muss eröffnet sein }
  275.  
  276. procedure EVEC(var x:realvec;n,chelem:integer;vname:string);external;
  277.  
  278. procedure EMAT(var a:realmat;n,m,chelem:integer;vname:string);external;
  279.  
  280. procedure BVEC(var x:realvec;n,chelem:integer;vname:string);external;
  281.  
  282. procedure BMAT(var a:realmat;n,m,chelem:integer;vname:string);external;
  283.  
  284. procedure PVEC(var x:realvec;n,chelem:integer;vname:string);external;
  285.  
  286. procedure PMAT(var a:realmat;n,m,chelem:integer;vname:string);external;
  287.  
  288. {# Darstellung eines Koordinatensystems:}
  289.  
  290. { Umwandlung ins Bildkoordinatensystem x:0..639, y:0..399 (hohe Auflösung)
  291.   Weltkoordinaten: t,x  Bildkoordinaten: h,v
  292.   inbild=TRUE, falls Punkt innerhalb der Bilschirmgrenzen }
  293. procedure REALTOBILD(t,x:real;ap:koopa;var h,v:integer;var inbild:boolean);
  294. external;
  295.  
  296. { Umkehrfunktion von REALTOBILD }
  297. procedure BILDTOREAL(h,v:integer;ap:koopa;var t,x:real;var inreal:boolean);
  298. external;
  299.  
  300. { Zeichnet ein Achsenkreuz ein und setzt die Steigungen in ap für die
  301.   die linearen Transformationen REALTOBILD und BILDTOREAL }
  302. procedure AXIS(var ap:koopa);external;
  303.  
  304. { Eingabe der notwendigen Parameter, um ein Achsenkreuz zu zeichnen }
  305. procedure KOORDFESTLEGEN(var ap:koopa);external;
  306.  
  307. { Markiert den Bildpunkt h,v mit einem kleinen Kreuz }
  308. procedure MARKPOINT(h,v:integer);external;
  309.  
  310. { Zeichnet eine Funktion in ein bestehendes Koordinatensystem ein,
  311.   von t bis te mit intervalle Zwischenpunkten.
  312.   wie=0: Nur einzelne Punkte
  313.   wie=1: Punkte sind durch Geraden verbunden
  314.   mark=true: Punkte werden markiert }
  315. procedure ZEICHNEFUNKTION(function x(t:real):real;ap:koopa;t,te:real;
  316.                           intervalle,wie:integer;mark:boolean);external;
  317.  
  318. { Bringt eine Funktion einschliesslich Koordinatensystem auf den Bildschirm }
  319. procedure DISPLAYFUNKTION(function x(t:real):real);external;
  320.  
  321. {# Ablaufsuche einer Funktion x(t)
  322.  # auf Nullstellen, Maxima, Minima, Wechselpunkte und Sprünge:}
  323.  
  324. { Sucht eine Nullstelle zwischen l und r mit den Genauigkeiten epst und epsx }
  325. procedure BISEK(function X(t:real):real;l,r,epst,epsx:real;var t,xx:real);
  326. external;
  327.  
  328. { Sucht ein Extremum zwischen l und r mit den Genauigkeiten epst und epsx,
  329.   max=1 suche Maximum
  330.   max=-1 suche Minimum }
  331. procedure BIMINMAX(function X(t:real):real;
  332.                    l,r,epst,epsx:real;max:integer;var t,xx:real);external;
  333.  
  334. { Sucht einen Wechselpunkt
  335.   zwischen l und r mit den Genauigkeiten epst und epsx }
  336. procedure WECHSELPUNKT(function X(t:real):real;
  337.                        l,r,epst:real;var t,xx:real;var gefunden:boolean);
  338. external;
  339.  
  340. { Sucht einen Sprung zwischen l und r mit den Genauigkeiten epst und epsx }
  341. procedure SPRUNG(function X(t:real):real;
  342.                  l,r,epst:real;var t:real;var gefunden:boolean);external;
  343.  
  344. { Ablaufsuche: eine Funktion wird in den Grenzen t,te mit der
  345.   Schrittweite h mit den Genauigkeiten epst,epsx nach Nullstellen,
  346.   Extramas, Wechselpunkten und Sprüngen abgesucht.
  347.   Das Ergebnis steht in ip:
  348.   ip.p:Art des Ereignisses:1=Nullstelle
  349.                            2=Maximum
  350.                            3=Minimum
  351.                            4=Wechselpunkt
  352.                            5=Sprung
  353.   ip.t:t-Koordinate des entsprechenden Ereignisses
  354.   ip.x:x-Koordinate
  355.   nst:Anzahl der in ip verfügbaren Speicheplätze }
  356. procedure SCANFUNKTION(function X(t:real):real;
  357.                        t,te,h,epst,epsx:real;nst:integer;var ip:scanvec);
  358. external;
  359.  
  360. { Formatierte Ausgabe der durch SCANFUNKTION gefundenen Ereignisse }
  361. procedure SCANVECBILD(ip:scanvec);external;
  362.  
  363. {# Finden von Nullstellen nach dem Sekantenverfahren:
  364.  # Das Hauptprogramm benoetigt die Vereinbarung der function X(t:real):real;
  365.  # Eingabe Startwert in t
  366.  # Ausgabe Enderte t,x
  367.  #  itmax: >0 :Erfolg, Werte brauchbar
  368.  #         =0 :itmax Iteration durchgefuehrt
  369.  #         <0 :x(tn)=x(tn-1), keine weitere Berechnung
  370.  #             mehr moeglich }
  371. procedure SEKANT(function X(t:real):real;
  372.                  var t,f:real;epst,epsx:real;var itmax:integer);external;
  373.  
  374. {# Verarbeitung komplexer Zahlen:
  375.  # !Achtung ARCCSIN,ARCCCOS,ARCCTAN sind reine Näherungsverfahren und mit
  376.  # !Vorsicht zu geniessen in Bezug auf Genauigkeit und Konvergenz }
  377.  
  378. { z=v }
  379. procedure CLET(var z:complex;v:complex);external;
  380.  
  381. procedure CNEG(var z:complex);external;
  382.  
  383. procedure CKON(var z:complex);external;
  384.  
  385. { z=z+v }
  386. procedure CADD(var z:complex;v:complex);external;
  387.  
  388. { z=z-v }
  389. procedure CSUB(var z:complex;v:complex);external;
  390.  
  391. { z=z*v }
  392. procedure CMUL(var z:complex;v:complex);external;
  393.  
  394. { z=z/v }
  395. procedure CDIV(var z:complex;v:complex);external;
  396.  
  397. { z=z+-*/eine Zahl r+j*s }
  398.  
  399. procedure CADDZ(var z:complex;r,s:real);external;
  400.  
  401. procedure CSUBZ(var z:complex;r,s:real);external;
  402.  
  403. procedure CMULZ(var z:complex;r,s:real);external;
  404.  
  405. procedure CDIVZ(var z:complex;r,s:real);external;
  406.  
  407. { z=v+-*/w }
  408.  
  409. procedure CPLUS(v,w:complex;var z:complex);external;
  410.  
  411. procedure CMINUS(v,w:complex;var z:complex);external;
  412.  
  413. procedure CMAL(v,w:complex;var z:complex);external;
  414.  
  415. procedure CDURCH(v,w:complex;var z:complex);external;
  416.  
  417. { Reziprokwert }
  418. procedure CREZI(var z:complex);external;
  419.  
  420. function CBETRAG(z:complex):real;external;
  421.  
  422. function CARG(z:complex):real;external;
  423.  
  424. procedure CEXP(v:complex;var z:complex);external;
  425.  
  426. procedure CLN(v:complex;var z:complex);external;
  427.  
  428. procedure CSIN(v:complex;var z:complex);external;
  429.  
  430. procedure CCOS(v:complex;var z:complex);external;
  431.  
  432. procedure CTAN(v:complex;var z:complex);external;
  433.  
  434. { z=v^r }
  435. procedure CHOCHR(v:complex;r:real;var z:complex);external;
  436.  
  437. procedure CSQRT(v:complex;var z:complex);external;
  438.  
  439. { rte Wurzel aus v }
  440. procedure CRWURZ(v:complex;r:real;var z:complex);external;
  441.  
  442. procedure ARCCSIN(v:complex;var z:complex);external;
  443.  
  444. procedure ARCCCOS(v:complex;var z:complex);external;
  445.  
  446. procedure ARCCTAN(v:complex;var z:complex);external;
  447.  
  448. { komplexe quadratische Gleichung x^2+p*x+q=0,
  449.   Lösungen z,s }
  450. procedure CQUADGL(p,q:complex;var z,s:complex);external;
  451.  
  452. { Input, Bildschirmausgabe, Druckerausgabe komplexe Zahl }
  453.  
  454. procedure ICOM(var z:complex;c:string);external;
  455.  
  456. procedure BCOM(z:complex;c:string);external;
  457.  
  458. procedure PCOM(z:complex;c:string);external;
  459.  
  460. {# Lösen von Polynomgleichungen bis zum Grade 4: }
  461.  
  462. { die Lösung ist in lsg enthalten:
  463.   lsg[ ,0]:Realteil
  464.   lsg[ ,1]:Imaginärteil
  465.   lsgan:Anzahl der Lösungen
  466.    lsgan<0:keine Lösung
  467.    lsgan=0:Lösung beliebig }
  468.  
  469. procedure LINGL(A,B:real;var lsg:polygl;var lsgan:integer);external;
  470.  
  471. procedure QUADGL(A,B,C:real;var lsg:polygl;var lsgan:integer);external;
  472.  
  473. procedure KUBGL(D,A,B,C:real;var lsg:polygl;var lsgan:integer);external;
  474.  
  475. procedure VIERGL(E,A,B,C,D:real;var lsg:polygl;var lsgan:integer);external;
  476.  
  477. { Formatierte Ausgabe der gefundenen Lösungen }
  478. procedure AUSLSG(lsgan:integer;lsg:polygl);external;
  479.  
  480. {# Sammlung aller function und procedure aus MATHLIB2:
  481.  # Lösen von Gleichungssystemen : }
  482.  
  483. { Lgs nach dem Gaussvefahren mit Zeilenpivotsuche: }
  484. procedure LGSGAUSS (n:integer;a:realmat;b:realvec;
  485.                     var x:realvec;var erfolg:boolean);external;
  486.  
  487. { loest ein GLS nach dem allgemeinen Newtonverfahren:
  488.   h: Schrittweite fuer die partiellen Ableitungen
  489.   Abbruchkriterien:
  490.   epsdx: Grenze fuer den Bertrag des Aenderungsvektors dx
  491.   epsf: Grenze fuer den Betrag des Funktionenvektors f
  492.   maxit: Groesstmoegliche Anzahl der Iterationen
  493.   konv=false bei - Iterationen>maxit
  494.                  - dx0>dx1>dx2 oder f0>f1>f2
  495.                  - LGS fuer dx singulaer
  496.   Vereinbarung der Funktionen :procedure FUNKVEC(var f:realvec;x:realvec);}
  497. procedure GENEWTON(procedure FUNKVEC(var f:realvec;x:realvec);
  498.                    n:integer;var x:realvec;
  499.                    h,epsdx,epsf:real;maxit:integer;var konv:boolean);
  500. external;
  501.  
  502. {# Hilfsprocedures für Matrizen:}
  503.  
  504. { füllt eine Matrix mit w; a:n x m -Matrix }
  505. procedure FILLMAT(var a:realmat;n,m:integer;w:real);external;
  506.  
  507. { erzeugt Einheitsmatrix, soweit als möglich; a:n x m -Matrix }
  508. procedure EINHEITSMAT(var a:realmat;n,m:integer);external;
  509.  
  510. { Matrix a= Matrix b; a,b:n x m -Matrizen }
  511. procedure LETMAT(var a:realmat;b:realmat;n,m:integer);external;
  512.  
  513. { negiert Matrix; a:n x m -Matrix }
  514. procedure NEGMAT(var a:realmat;n,m:integer);external;
  515.  
  516. { transponiert Matrix, soweit als möglich; a:n x m -Matrix }
  517. procedure TRANSMAT(var a:realmat;n,m:integer);external;
  518.  
  519. { Matrizenaddition, c=a+b; a,b,c:n x m -Matrizen }
  520. procedure ADDMAT(a,b:realmat;var c:realmat;n,m:integer);external;
  521.  
  522. { Matrizensubtraktion, c=a-b; a,b,c:n x m -Matrizen }
  523. procedure SUBMAT(a,b:realmat;var c:realmat;n,m:integer);external;
  524.  
  525. { Matrizenmultiplikation, c=a*b;
  526.   a:n x m -Matrix, b:m x l -Matrix, c:l x m -Matrix }
  527. procedure MATMULMAT(a,b:realmat;var c:realmat;n,m,l:integer);external;
  528.  
  529. { Multipliziert Matrix mit Vektor c=a*b;
  530.   a:n x m -Matrix, b:n -Vector, c:m -Vector }
  531. procedure MATMULVEC(a:realmat;b:realvec;var c:realvec;n,m:integer);external;
  532.  
  533. { Multipliziert Matrix a mit Faktor w; a:n x m -Matrix  }
  534. procedure FACMULMAT(var a:realmat;n,m:integer;w:real);external;
  535.  
  536. { Berechnet Obere Dreiecksmatrix mit elementaren Umformungen;
  537.   a:n x n -Matrix }
  538. procedure ODREIMAT(var a:realmat;n:integer);external;
  539.  
  540. { Berechnet Determinante; a:n x n -Matrix }
  541. procedure DETERMINANTE(a:realmat;n:integer;var det:real);external;
  542.  
  543. { Invertiert Matrix (falls möglich) nach dem Sweeping-Out-Verfahren }
  544. procedure SWEEPOUT(var a:realmat;n:integer;gelungen:boolean);external;
  545.  
  546. { Invertiert Matrix (falls möglich) nach dem Stiefel-Verfahren,
  547.   langsamer aber genauer als SWEEPOUT }
  548. procedure STIEFEL(var a:realmat;n:integer;var gelungen:boolean);external;
  549.  
  550. {# Differentiation einer function X(t:real):real; }
  551.  
  552. { Berechnet die Ableitung Nr.abl (abl<=4) im Punkt t einer Funktion
  553.   mit der Schrittweite h, die Ableitung steht in xp }
  554. procedure DIFFERPUNKT(function X(t:real):real;
  555.                       t,h:real;var abl:integer;var xp:real);external;
  556.  
  557. { Wie vor, jedoch wird ein Intervall ta,te mit der Unterteilung intv
  558.   berechnet die intv+1 Ableitungswerte stehen in xp.
  559.   Achtung: intv darf nicht grösser sein als die Dimension von REALVEC,
  560.   soll die Unterteilung feiner sein, einfach DIFFERINTV mehrmals
  561.   aufrufen }
  562. procedure DIFFERINTV(function X(t:real):real;
  563.                      ta,te:real;var abl:integer;intv:integer;
  564.                      var xp:realvec);external;
  565.  
  566. {# Das bestimmte Integral der
  567.  # function X(t:real):real;
  568.  # in den Grenzen ta,tb; Anzahl der Berechnungsschritte iv }
  569. procedure WEDDLER(ta,tb:real;iv:integer;var w:real);external;
  570.  
  571. {# Lösen von Differentialgleichungssystemen : }
  572.  
  573. { Runge-Kutta-Verfahren 4./7. Ordnung :
  574.   Eingabe  n: Dimension-1
  575.            ta,te: Intervallgrenzen
  576.            h: Schrittweite
  577.            xa: Anfangswerte x(ta)
  578.   Ausgabe  xa: Endwerte x(te) }
  579.  
  580. procedure RK4(procedure F(t:real;x:realvec;var dx:realvec);
  581.               n:integer;ta,te,h:real;var xa:realvec);external;
  582.  
  583. procedure RK7(procedure F(t:real;x:realvec;var dx:realvec);
  584.               n:integer;ta,te,h:real;var xa:realvec);external;
  585.  
  586. {# Das war's & viel Spaß: Magnus Knobel, Rotkreuzstr. 51 A, 8058 Erding #}
  587.