home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / l / l042 / 2.ddi / CHAP8.ARC / INITVAL.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1987-12-30  |  37.9 KB  |  573 lines
  1. unit InitVal;
  2.  
  3. {----------------------------------------------------------------------------}
  4. {-                                                                          -}
  5. {-     Turbo Pascal Numerical Methods Toolbox                               -}
  6. {-     Copyright (c) 1986, 87 by Borland International, Inc.                -}
  7. {-                                                                          -}
  8. {-  This unit provides procedures for solving:                              -}
  9. {-                                                                          -}
  10. {-  (1) Initial value problems for nth-order ordinary differential          -}
  11. {-      equations.                                                          -}
  12. {-                                                                          -}
  13. {-  (2) Initial value problems for systems of coupled first-order           -}
  14. {-      ordinary differential equations.                                    -}
  15. {-                                                                          -}
  16. {-  (3) Boundary value problems for second-order ordinary differential      -}
  17. {-      equations.                                                          -}
  18. {-                                                                          -}
  19. {----------------------------------------------------------------------------}
  20.  
  21. {$I Float.inc} { Determines the setting of the $N compiler directive }
  22.  
  23. interface
  24.  
  25. {$IFOPT N+}
  26. type
  27.   Float = Double; { 8 byte real, requires 8087 math chip }
  28.  
  29. const
  30.   TNNearlyZero = 1E-015;
  31. {$ELSE}
  32. type
  33.   Float = real;   { 6 byte real, no math chip required }
  34.  
  35. const
  36.   TNNearlyZero = 1E-07;
  37. {$ENDIF}
  38.  
  39.   TNArraySize  = 50;           { Maximum size of vectors }
  40.   MaxFuncs     = 10;           { Maximum number of user defined functions }
  41.  
  42. type
  43.   TNvector  = array[0..TNArraySize] of Float;
  44.   TNmatrix  = array[0..TNArraySize] of TNvector;
  45.   TNData    = record
  46.                 X : Float;
  47.                 xDeriv : Float;
  48.               end;
  49.  
  50.   TNvector2 = array[0..TNArraySize] of TNData;
  51.   TNmatrix2 = array[0..TNArraySize] of TNvector2;
  52.   FuncVect  = array[1..MaxFuncs] of Pointer;
  53.  
  54. procedure InitialCond1stOrder(LowerLimit   : Float;
  55.                               UpperLimit   : Float;
  56.                               XInitial     : Float;
  57.                               NumReturn    : integer;
  58.                               NumIntervals : integer;
  59.                           var TValues      : TNvector;
  60.                           var XValues      : TNvector;
  61.                           var Error        : byte;
  62.                               FuncPtr      : Pointer);
  63.  
  64. {----------------------------------------------------------------------------}
  65. {-                                                                          -}
  66. {-    Input:  LowerLimit, UpperLimit, XInitial, NumIntervals, NumReturn     -}
  67. {-   Output:  TValues, XValues, Error                                       -}
  68. {-                                                                          -}
  69. {-  Purpose:  This unit solves a first order ordinary differential equation -}
  70. {-            with initial condition specified).                            -}
  71. {-            Given a function of the form                                  -}
  72. {-                       dx/dt = TNTargetF(T, X)                            -}
  73. {-            and an initial condition                                      -}
  74. {-                       X[LowerLimit] = XInitial                           -}
  75. {-            the fourth order Runge-Kutta method is used to solve for X    -}
  76. {-            in the interval [LowerLimit, UpperLimit].  The interval is    -}
  77. {-            divided up into NumIntervals sub-intervals.                   -}
  78. {-                                                                          -}
  79. {-  User-defined Functions: TNTargetF(T, X : real) : real;                  -}
  80. {-                                                                          -}
  81. {-      User-defined Types: TNvector = array[0..TNArraySize] of real;       -}
  82. {-                                                                          -}
  83. {-    Global Variables:  LowerLimit : real;      Lower limit of interval    -}
  84. {-                       UpperLimit : real;      Upper limit of interval    -}
  85. {-                       XInitial : real;        Initial value at LowerLimit-}
  86. {-                       NumIntervals : integer; Number of subintervals     -}
  87. {-                       NumReturn : integer;    Number of values to return -}
  88. {-                       TValues : TNvector;     Value of T between limits  -}
  89. {-                       XValues : TNvector;     Value of X at TValues      -}
  90. {-                       Error : byte;           Flags if something goes    -}
  91. {-                                               wrong                      -}
  92. {-                                                                          -}
  93. {-               Notes:  NumIntervals should be an integer                  -}
  94. {-                       multiple of NumReturn if you want                  -}
  95. {-                       evenly spaced values returned.                     -}
  96. {-                                                                          -}
  97. {-              Errors:  0: No errors                                       -}
  98. {-                       1: NumReturn < 1                                   -}
  99. {-                       2: NumIntervals < NumReturn                        -}
  100. {-                       3: LowerLimit = UpperLimit                         -}
  101. {-                                                                          -}
  102. {----------------------------------------------------------------------------}
  103.  
  104. procedure RungeKuttaFehlberg(LowerLimit : Float;
  105.                              UpperLimit : Float;
  106.                              XInitial   : Float;
  107.                              Tolerance  : Float;
  108.                              NumReturn  : integer;
  109.                          var TValues    : TNvector;
  110.                          var XValues    : TNvector;
  111.                          var Error      : byte;
  112.                              FuncPtr    : Pointer);
  113.  
  114. {----------------------------------------------------------------------------}
  115. {-                                                                          -}
  116. {-    Input:  LowerLimit, UpperLimit, XInitial, Tolerance, NumReturn        -}
  117. {-   Output:  TValues, XValues, Error                                       -}
  118. {-                                                                          -}
  119. {-  Purpose:  This unit solves a first order ordinary differential equation -}
  120. {-            with a specified initial condition.                           -}
  121. {-            Given a function of the form                                  -}
  122. {-                       X' = TNTargetF(T, X)                               -}
  123. {-            and an initial condition                                      -}
  124. {-                       X[LowerLimit] = XInitial                           -}
  125. {-            the Runge-Kutta-Fehlberg method is used to solve for X in the -}
  126. {-            interval [LowerLimit, UpperLimit] with a given Tolerance.     -}
  127. {-                                                                          -}
  128. {-  User-defined Functions: TNTargetF(T, X : real) : real;                  -}
  129. {-                                                                          -}
  130. {-      User-defined Types: TNvector = array[0..TNArraySize] of real;       -}
  131. {-                                                                          -}
  132. {-    Global Variables:  LowerLimit : real;     Lower limit of integration  -}
  133. {-                       UpperLimit : real;     Upper limit of integration  -}
  134. {-                       XInitial   : real;     Value of X at T=LowerLimit  -}
  135. {-                       Tolerance  : real;     Tolerance in answer         -}
  136. {-                       NumReturn  : integer;  Number of values to return  -}
  137. {-                       TValues    : TNvector; Values of T                 -}
  138. {-                       XValues    : TNvector; Values of X at TValues      -}
  139. {-                       Error      : byte;     Flags if something goes     -}
  140. {-                                              wrong                       -}
  141. {-                                                                          -}
  142. {-                       0: No errors                                       -}
  143. {-                       1: Tolerance <= 0                                  -}
  144. {-                       2: NumReturn < 1                                   -}
  145. {-                       3: LowerLimit = UpperLimit                         -}
  146. {-                       4: Tolerance not reached                           -}
  147. {-                                                                          -}
  148. {----------------------------------------------------------------------------}
  149.  
  150. procedure Adams(LowerLimit   : Float;
  151.                 UpperLimit   : Float;
  152.                 XInitial     : Float;
  153.                 NumReturn    : integer;
  154.                 NumIntervals : integer;
  155.             var TValues      : TNvector;
  156.             var XValues      : TNvector;
  157.             var Error        : byte;
  158.                 FuncPtr      : Pointer);
  159.  
  160. {----------------------------------------------------------------------------}
  161. {-                                                                          -}
  162. {-    Input:  LowerLimit, UpperLimit, XInitial, NumReturn, NumIntervals     -}
  163. {-   Output:  TValues, XValues, Error                                       -}
  164. {-                                                                          -}
  165. {-  Purpose:  This unit solves an initial value problem (a first order      -}
  166. {-            differential equation with initial condition specified).      -}
  167. {-            Given a function of the form                                  -}
  168. {-                       dx/dt = TNTargetF(T, X)                            -}
  169. {-            and an initial condition                                      -}
  170. {-                       X[LowerLimit] = const                              -}
  171. {-            the Adams-Bashforth/Adams-Moulton four step predictor/        -}
  172. {-            corrector method is used to solve for X in  the interval      -}
  173. {-            [LowerLimit, UpperLimit].  The interval is divided up into    -}
  174. {-            NumIntervals equal sub-intervals.                             -}
  175. {-                                                                          -}
  176. {-  User-defined Functions: TNTargetF(T, X : real) : real;                  -}
  177. {-                                                                          -}
  178. {-      User-defined Types: TNvector = array[0..TNArraySize] of real;       -}
  179. {-                                                                          -}
  180. {-    Global Variables:  LowerLimit   : real;    Lower limit of integration -}
  181. {-                       UpperLimit   : real;    Upper limit of integration -}
  182. {-                       XInitial     : real;    Value of X at LowerLimit   -}
  183. {-                       NumReturn    : integer; Number of values to return -}
  184. {-                       NumIntervals : integer; Number of subintervals     -}
  185. {-                       TValues      : TNvector; Value of T between limits -}
  186. {-                       XValues      : TNvector; Value of X at TValues     -}
  187. {-                       Error        : byte;    Flags if something goes    -}
  188. {-                                               wrong                      -}
  189. {-                                                                          -}
  190. {-               Notes:  NumIntervals should be an integer                  -}
  191. {-                       multiple of NumReturn if you want                  -}
  192. {-                       evenly spaced values returned.                     -}
  193. {-                                                                          -}
  194. {-              Errors:  0: No errors                                       -}
  195. {-                       1: NumReturn <= 0                                  -}
  196. {-                       2: NumIntervals < NumReturn                        -}
  197. {-                       3: LowerLimit = UpperLimit                         -}
  198. {-                                                                          -}
  199. {----------------------------------------------------------------------------}
  200.  
  201. procedure InitialCond2ndOrder(LowerLimit   : Float;
  202.                               UpperLimit   : Float;
  203.                               InitialValue : Float;
  204.                               InitialDeriv : Float;
  205.                               NumReturn    : integer;
  206.                               NumIntervals : integer;
  207.                           var TValues      : TNvector;
  208.                           var XValues      : TNvector;
  209.                           var XDerivValues : TNvector;
  210.                           var Error        : byte;
  211.                               FuncPtr      : Pointer);
  212.  
  213. {----------------------------------------------------------------------------}
  214. {-                                                                          -}
  215. {-    Input:  LowerLimit, UpperLimit, InitialValue, InitialDeriv,           -}
  216. {-            NumIntervals, NumReturn                                       -}
  217. {-   Output:  NumIntervals, TValues, XValues, XDerivValues, Error           -}
  218. {-                                                                          -}
  219. {-  Purpose:  This unit solves a 2nd order ordinary differential            -}
  220. {-            equation with specified initial conditions.                   -}
  221. {-            Given a function of the form                                  -}
  222. {-                       X" = TNTargetF(T, X, X')                           -}
  223. {-            and initial conditions                                        -}
  224. {-                 X[LowerLimit] = InitialValue,                            -}
  225. {-                X'[LowerLimit] = InitialDeriv                             -}
  226. {-            the Runge-Kutta method of two variables (X and X') is used to -}
  227. {-            solve for X and X' in the interval [LowerLimit, UpperLimit].  -}
  228. {-            The interval is divided up into NumIntervals sub-intervals.   -}
  229. {-                                                                          -}
  230. {-  User-defined Functions: TNTargetF(T, X, xPrime: real) : real;           -}
  231. {-                                                                          -}
  232. {-      User-defined Types: TNvector = array[0..TNArraySize] of real;       -}
  233. {-                                                                          -}
  234. {-    Global Variables:  LowerLimit   : real;    Lower limit of integration -}
  235. {-                       UpperLimit   : real;    Upper limit of integration -}
  236. {-                       InitialValue : real;    Value of X at LowerLimit   -}
  237. {-                       InitialDeriv : real;    Deriv. of X at LowerLimit  -}
  238. {-                       NumReturn    : integer; Number of values to return -}
  239. {-                       NumIntervals : integer; Number of subintervals     -}
  240. {-                       TValues      : TNvector;Value of T between limits  -}
  241. {-                       XValues      : TNvector;Value of X at TValues      -}
  242. {-                       XDerivValues : TNvector Value of X' at TValues     -}
  243. {-                       Error        : byte;    Flags if something goes    -}
  244. {-                                               wrong                      -}
  245. {-                                                                          -}
  246. {-               Notes:  NumIntervals should be an integer                  -}
  247. {-                       multiple of NumReturn if you want                  -}
  248. {-                       evenly spaced values returned.                     -}
  249. {-                                                                          -}
  250. {-              Errors:  0: No errors                                       -}
  251. {-                       1: NumReturn < 1                                   -}
  252. {-                       2: NumIntervals < NumReturn                        -}
  253. {-                       3: LowerLimit = UpperLimit                         -}
  254. {-                                                                          -}
  255. {----------------------------------------------------------------------------}
  256.  
  257. procedure InitialCondition(Order          : integer;
  258.                            LowerLimit     : Float;
  259.                            UpperLimit     : Float;
  260.                            InitialValues  : TNvector;
  261.                            NumReturn      : integer;
  262.                            NumIntervals   : integer;
  263.                        var SolutionValues : TNmatrix;
  264.                        var Error          : byte;
  265.                            FuncPtr        : Pointer);
  266.  
  267. {----------------------------------------------------------------------------}
  268. {-                                                                          -}
  269. {-    Input:  Order, LowerLimit, UpperLimit, InitialValues,                 -}
  270. {-            NumReturn, NumIntervals                                       -}
  271. {-   Output:  SolutionValues, Error                                         -}
  272. {-                                                                          -}
  273. {-    Purpose:  This procedure solves an n-order ordinary differential      -}
  274. {-              equation with specified initial conditions.  The            -}
  275. {-              generalized Runge-Kutta method solves for the n parameters  -}
  276. {-              in a given interval.                                        -}
  277. {-                                                                          -}
  278. {-  User-defined Functions: TNTargetF(values : TNvector) : real;            -}
  279. {-                                                                          -}
  280. {-      User-defined Types: TNvector = array[0..TNArraySize] of real;           -}
  281. {-                          TNmatrix = array[0..TNColumnSize] of TNvector   -}
  282. {-                                                                          -}
  283. {-  Global Variables: Order : integer;           Order, n, of the diff. eq. -}
  284. {-                    LowerLimit : real;         Lower limit of integration -}
  285. {-                    UpperLimit : real;         Upper limit of integration -}
  286. {-                    InitialValues : real;      Initial values of          -}
  287. {-                                               The n parameters           -}
  288. {-                    NumReturn : integer;       Number of values to return -}
  289. {-                    NumIntervals : integer;    Number of subintervals     -}
  290. {-                    SolutionValues : TNmatrix  Values of the n parameters -}
  291. {-                                               at NumReturn points in the -}
  292. {-                                               interval.                  -}
  293. {-                    Error : byte;              Flags if something goes    -}
  294. {-                                               wrong                      -}
  295. {-                                                                          -}
  296. {-               Notes:  NumIntervals should be an integer                  -}
  297. {-                       multiple of NumReturn if you want                  -}
  298. {-                       evenly spaced values returned.                     -}
  299. {-                                                                          -}
  300. {-              Errors:  0: No errors                                       -}
  301. {-                       1: NumReturn < 1                                   -}
  302. {-                       2: NumIntervals < NumReturn                        -}
  303. {-                       3: Order < 1                                       -}
  304. {-                       4: LowerLimit = UpperLimit                         -}
  305. {-                                                                          -}
  306. {----------------------------------------------------------------------------}
  307.  
  308. procedure InitialConditionSystem(NumEquations   : integer;
  309.                                  LowerLimit     : Float;
  310.                                  UpperLimit     : Float;
  311.                                  InitialValues  : TNvector;
  312.                                  NumReturn      : integer;
  313.                                  NumIntervals   : integer;
  314.                              var SolutionValues : TNmatrix;
  315.                              var Error          : byte;
  316.                                  Vector         : FuncVect);
  317. {----------------------------------------------------------------------------}
  318. {-                                                                          -}
  319. {-    Input:  NumEquations, LowerLimit, UpperLimit, InitialValues,          -}
  320. {-            NumReturn, NumIntervals                                       -}
  321. {-   Output:  SolutionValues, Error                                         -}
  322. {-                                                                          -}
  323. {-    Purpose:  This procedure solves m 1st-order ordinary differential     -}
  324. {-              equation with specified initial conditions.  The            -}
  325. {-              generalized Runge-Kutta method solves for the m parameters  -}
  326. {-              in a given interval.                                        -}
  327. {-                                                                          -}
  328. {-  User-defined Functions: TNTargetF1(values : TNvector) : real;           -}
  329. {-                          TNTargetF2(values : TNvector) : real;           -}
  330. {-                          TNTargetF3(values : TNvector) : real;           -}
  331. {-                          TNTargetF4(values : TNvector) : real;           -}
  332. {-                          TNTargetF5(values : TNvector) : real;           -}
  333. {-                          TNTargetF6(values : TNvector) : real;           -}
  334. {-                          TNTargetF7(values : TNvector) : real;           -}
  335. {-                          TNTargetF8(values : TNvector) : real;           -}
  336. {-                          TNTargetF9(values : TNvector) : real;           -}
  337. {-                          TNTargetF10(values : TNvector) : real;          -}
  338. {-                                                                          -}
  339. {-    User-defined Types: TNvector = array[0..TNRowSize] of real;           -}
  340. {-                        TNmatrix = array[0..TNColumnSize] of TNvector     -}
  341. {-                                                                          -}
  342. {-  Global Variables: NumEquations : integer;    Order & number of eqs.     -}
  343. {-                    LowerLimit : real;         Lower limit of integration -}
  344. {-                    UpperLimit : real;         Upper limit of integration -}
  345. {-                    InitialValues : real;      Initial values of          -}
  346. {-                                               The m parameters           -}
  347. {-                    NumReturn : integer;       Number of values to return -}
  348. {-                    NumIntervals : integer;    Number of subintervals     -}
  349. {-                    SolutionValues : TNmatrix  Values of the m parameters -}
  350. {-                                               at NumReturn points in the -}
  351. {-                                               interval.                  -}
  352. {-                    Error : byte;              Flags if something goes    -}
  353. {-                                               wrong                      -}
  354. {-                                                                          -}
  355. {-               Notes:  NumIntervals should be an integer                  -}
  356. {-                       multiple of NumReturn if you want                  -}
  357. {-                       evenly spaced values returned.                     -}
  358. {-                                                                          -}
  359. {-              Errors:  0: No errors                                       -}
  360. {-                       1: NumReturn < 1                                   -}
  361. {-                       2: NumIntervals < NumReturn                        -}
  362. {-                       3: NumEquations < 1                                -}
  363. {-                       4: LowerLimit = UpperLimit                         -}
  364. {-                                                                          -}
  365. {----------------------------------------------------------------------------}
  366.  
  367. procedure InitialConditionSystem2(NumEquations   : integer;
  368.                                   LowerLimit     : Float;
  369.                                   UpperLimit     : Float;
  370.                                   InitialValues  : TNvector2;
  371.                                   NumReturn      : integer;
  372.                                   NumIntervals   : integer;
  373.                               var SolutionValues : TNmatrix2;
  374.                               var Error          : byte;
  375.                                   Vector         : FuncVect);
  376.  
  377. {----------------------------------------------------------------------------}
  378. {-                                                                          -}
  379. {-    Input:  NumEquations, LowerLimit, UpperLimit, InitialValues,          -}
  380. {-            NumReturn, NumIntervals                                       -}
  381. {-   Output:  SolutionValues, Error                                         -}
  382. {-                                                                          -}
  383. {-    Purpose:  This procedure solves m 2nd-order ordinary differential     -}
  384. {-              equation with specified initial conditions.  The            -}
  385. {-              generalized Runge-Kutta method solves for the m parameters  -}
  386. {-              in a given interval.                                        -}
  387. {-                                                                          -}
  388. {-  User-defined Functions: TNTargetF1(values : TNvector2) : real;          -}
  389. {-                          TNTargetF2(values : TNvector2) : real;          -}
  390. {-                          TNTargetF3(values : TNvector2) : real;          -}
  391. {-                          TNTargetF4(values : TNvector2) : real;          -}
  392. {-                          TNTargetF5(values : TNvector2) : real;          -}
  393. {-                          TNTargetF6(values : TNvector2) : real;          -}
  394. {-                          TNTargetF7(values : TNvector2) : real;          -}
  395. {-                          TNTargetF8(values : TNvector2) : real;          -}
  396. {-                          TNTargetF9(values : TNvector2) : real;          -}
  397. {-                          TNTargetF10(values : TNvector2) : real;         -}
  398. {-                                                                          -}
  399. {-    User-defined Types: TNData = record                                   -}
  400. {-                                   X : real;                              -}
  401. {-                                   xDeriv : real;                         -}
  402. {-                                 end;                                     -}
  403. {-                        TNvector2 = array[0..TNArraySize] of TNData;      -}
  404. {-                        TNmatrix2 = array[0..TNArraySize] of TNvector2;   -}
  405. {-                                                                          -}
  406. {-  Global Variables: NumEquations   : integer; Order & number of eqs.      -}
  407. {-                    LowerLimit     : real;    Lower limit of integration  -}
  408. {-                    UpperLimit     : real;    Upper limit of integration  -}
  409. {-                    InitialValues  : real;    Initial values of           -}
  410. {-                                              the m parameters            -}
  411. {-                    NumReturn      : integer; Number of values to return  -}
  412. {-                    NumIntervals   : integer; Number of subintervals      -}
  413. {-                    SolutionValues : TNmatrix Values of the m parameters  -}
  414. {-                                              at NumReturn points in the  -}
  415. {-                                              interval.                   -}
  416. {-                    Error          : byte;    Flags if something goes     -}
  417. {-                                              wrong                       -}
  418. {-                                                                          -}
  419. {-               Notes:  NumIntervals should be an integer                  -}
  420. {-                       multiple of NumReturn if you want                  -}
  421. {-                       evenly spaced values returned.                     -}
  422. {-                                                                          -}
  423. {-              Errors:  0: No errors                                       -}
  424. {-                       1: NumReturn < 1                                   -}
  425. {-                       2: NumIntervals < NumReturn                        -}
  426. {-                       3: NumEquations < 1                                -}
  427. {-                       4: LowerLimit = UpperLimit                         -}
  428. {-                                                                          -}
  429. {----------------------------------------------------------------------------}
  430.  
  431. procedure Shooting(LowerLimit   : Float;
  432.                    UpperLimit   : Float;
  433.                    LowerInitial : Float;
  434.                    UpperInitial : Float;
  435.                    InitialSlope : Float;
  436.                    NumReturn    : integer;
  437.                    Tolerance    : Float;
  438.                    MaxIter      : integer;
  439.                    NumIntervals : integer;
  440.                var Iter         : integer;
  441.                var XValues      : TNvector;
  442.                var YValues      : TNvector;
  443.                var YDerivValues : TNvector;
  444.                var Error        : byte;
  445.                    FuncPtr      : Pointer);
  446.  
  447. {----------------------------------------------------------------------------}
  448. {-                                                                          -}
  449. {-    Input:  LowerLimit, UpperLimit, LowerInitial, UpperInitial,           -}
  450. {-            InitialSlope, NumReturn, Tolerance, MaxIter, NumIntervals     -}
  451. {-   Output:  Iter, XValues, YValues, YDerivValues, Error                   -}
  452. {-                                                                          -}
  453. {-  Purpose:  This unit solves a possibly non-linear 2nd order ordinary     -}
  454. {-            differential equation with specified boundary conditions.     -}
  455. {-            Given a possible non-linear function of the form              -}
  456. {-                       Y" = TNTargetF(X, Y, Y')                           -}
  457. {-            and boundary conditions                                       -}
  458. {-              Y[LowerLimit] = LowerInitial, Y[UpperLimit] = UpperInitial  -}
  459. {-            the Runge-Kutta method is used to solve for Y in              -}
  460. {-            the interval [LowerLimit, UpperLimit].  The algorithm uses    -}
  461. {-            sub-intervals of length Spacing but returns only NumReturn    -}
  462. {-            points.                                                       -}
  463. {-                                                                          -}
  464. {-  User-defined Functions: TNTargetF(X, Y, yPrime : real) : real;          -}
  465. {-                                                                          -}
  466. {-      User-defined Types: TNvector = array[0..TNArraySize] of real;       -}
  467. {-                                                                          -}
  468. {-    Global Variables:  LowerLimit   : real;    Lower limit of integration -}
  469. {-                       UpperLimit   : real;    Upper limit of integration -}
  470. {-                       LowerInitial : real;    Value of Y at LowerLimit   -}
  471. {-                       UpperInitial : real;    Value of Y at UpperLimit   -}
  472. {-                       InitialSlope : real;    Guess of slope @ LowerLimit-}
  473. {-                       NumReturn    : integer; Number of points returned  -}
  474. {-                       Tolerance    : real;    Tolerance in answer        -}
  475. {-                       MaxIter      : integer; Max number of iterations   -}
  476. {-                       NumIntervals : integer; Number of the sub-intervals-}
  477. {-                       Iter         : integer; Number of iterations       -}
  478. {-                       XValues      : TNvector;Values of X between limits -}
  479. {-                       YValues      : TNvector;Value of Y at XValues      -}
  480. {-                       YDerivValues : TNvector Value of Y' at XValues     -}
  481. {-                       Error        : byte;    Flags if something goes    -}
  482. {-                                               wrong                      -}
  483. {-                                                                          -}
  484. {-               Notes:  NumIntervals should be an integer                  -}
  485. {-                       multiple of NumReturn if you want                  -}
  486. {-                       evenly spaced values returned.                     -}
  487. {-                                                                          -}
  488. {-              Errors:  0: No errors                                       -}
  489. {-                       1: NumReturn < 0                                   -}
  490. {-                       2: NumIntervals < NumReturn                        -}
  491. {-                       3: LowerLimit = UpperLimit                         -}
  492. {-                       4: Tolerance <= 0                                  -}
  493. {-                       5: MaxIter <= 0                                    -}
  494. {-                       6: Iter > MaxIter                                  -}
  495. {-                       7: Convergence not possible                        -}
  496. {-                                                                          -}
  497. {----------------------------------------------------------------------------}
  498.  
  499. procedure LinearShooting(LowerLimit   : Float;
  500.                          UpperLimit   : Float;
  501.                          LowerInitial : Float;
  502.                          UpperInitial : Float;
  503.                          NumReturn    : integer;
  504.                          NumIntervals : integer;
  505.                      var XValues      : TNvector;
  506.                      var YValues      : TNvector;
  507.                      var YDerivValues : TNvector;
  508.                      var Error        : byte;
  509.                          FuncPtr      : Pointer);
  510.  
  511. {----------------------------------------------------------------------------}
  512. {-                                                                          -}
  513. {-    Input:  LowerLimit, UpperLimit, LowerInitial, UpperInitial,           -}
  514. {-            NumReturn, NumIntervals                                       -}
  515. {-   Output:  XValues, YValues, YDerivValues                                -}
  516. {-                                                                          -}
  517. {-  Purpose:  This unit solves a 2nd order ordinary linear differential     -}
  518. {-            equation with specified boundary conditions.                  -}
  519. {-            Given a linear function of the form                           -}
  520. {-                       Y" = TNTargetF(X, Y, Y')                           -}
  521. {-            and boundary conditions                                       -}
  522. {-              Y[LowerLimit] = LowerInitial, Y[UpperLimit] = UpperInitial  -}
  523. {-            the Runge-Kutta method is used to solve for Y in              -}
  524. {-            the interval [LowerLimit, UpperLimit].  The algorithm uses    -}
  525. {-            sub-intervals of length Spacing.                              -}
  526. {-                                                                          -}
  527. {-  User-defined Functions: TNTargetF(X, Y, YPrime : real) : real;          -}
  528. {-                                                                          -}
  529. {-      User-defined Types: TNvector = array[0..TNArraySize] of real;       -}
  530. {-                                                                          -}
  531. {-    Global Variables:  LowerLimit : real;      Lower limit of integration -}
  532. {-                       UpperLimit : real;      Upper limit of integration -}
  533. {-                       LowerInitial : real;    Value of Y at LowerLimit   -}
  534. {-                       UpperInitial : real;    Value of Y at UpperLimit   -}
  535. {-                       NumIntervals : real;    Number of the sub-intervals-}
  536. {-                       NumReturn : integer;    Number of points returned  -}
  537. {-                       XValues : TNvector;     Values of X between limits -}
  538. {-                       YValues : TNvector;     Value of Y at XValues      -}
  539. {-                       YDerivValues : TNvector Value of Y' at XValues     -}
  540. {-                       Error : byte;           Flags if something goes    -}
  541. {-                                               wrong                      -}
  542. {-                                                                          -}
  543. {-               Notes:  NumIntervals should be an integer                  -}
  544. {-                       multiple of NumReturn if you want                  -}
  545. {-                       evenly spaced values returned.                     -}
  546. {-                                                                          -}
  547. {-              Errors:  0: No errors                                       -}
  548. {-                       1: NumReturn < 1                                   -}
  549. {-                       2: NumIntervals < NumReturn                        -}
  550. {-                       3: LowerLimit = UpperLimit                         -}
  551. {-                       4: Equation not linear                             -}
  552. {-                                                                          -}
  553. {----------------------------------------------------------------------------}
  554.  
  555. implementation
  556.  
  557. {$L InitVal.OBJ}
  558. {$F+}
  559. function UserFunction1(T, X : Float; ProcAddr : Pointer) : Float; external;
  560.  
  561. function UserFunction2(T, X, XPrime : Float; ProcAddr : Pointer) : Float; external;
  562.  
  563. function UserFunction3(V : TNvector; ProcAddr : Pointer) : Float; external;
  564.  
  565. function UserFunction4(V : TNvector2; ProcAddr : Pointer) : Float; external;
  566. {$F-}
  567.  
  568. {$I InitVal1.inc}   { Include procedure code }
  569.  
  570. {$I InitVal2.inc}
  571.  
  572. end. { InitVal }
  573.