home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / l / l042 / 2.ddi / CHAP8.ARC / RUNGE_S2.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1987-12-30  |  26.2 KB  |  635 lines
  1. program InitialConditionSystem2_Prog;
  2.  
  3. {----------------------------------------------------------------------------}
  4. {-                                                                          -}
  5. {-     Turbo Pascal Numerical Methods Toolbox                               -}
  6. {-     Copyright (c) 1986, 87 by Borland International, Inc.                -}
  7. {-                                                                          -}
  8. {- Purpose:  This unit demonstrates the procedure InitialConditionSystem2.  -}
  9. {-           This procedure solves a system of n 2nd order ordinary         -}
  10. {-           differential equations with initial conditions specified       -}
  11. {-           using the fourth order Runge-Kutta formula.                    -}
  12. {-                                                                          -}
  13. {- Unit   :  InitVal    procedure InitialConditionSystem2                   -}
  14. {-                                                                          -}
  15. {----------------------------------------------------------------------------}
  16.  
  17. {$I-}      { Disable I/O error trapping  }
  18. {$R+}      { Enable range checking  }
  19.  
  20. uses
  21.   InitVal, Dos, Crt, Common;
  22.  
  23. const
  24.   TNRowSize    = TNArraySize;    { Maximum number of diff. eqs.  }
  25.   TNColumnSize = TNArraySize;    { Maximum size of vectors  }
  26.  
  27. var
  28.   NumEquations : integer;        { The number of 2nd order equations  }
  29.   LowerLimit : Float;            { Lower limit of interval  }
  30.   UpperLimit : Float;            { Upper limit of interval  }
  31.   InitialValues : TNvector2;     { Initial values at lower limit  }
  32.   NumReturn : integer;           { Number of values to return  }
  33.   NumIntervals : integer;        { Number of intervals  }
  34.   SolutionValues : TNmatrix2;    { Values of the n parameters at NumReturn  }
  35.                                  { Mesh points between the intervals  }
  36.   Error : byte;                  { Flags if something went wrong  }
  37.   Vector : FuncVect;             { Pointers to user defined functions }
  38.  
  39. {$F+}
  40. function TNTargetF1(V : TNvector2) : Float;
  41.  
  42. {-------------------------------------------------------}
  43. {- This is the first differential equation.            -}
  44. {-                                                     -}
  45. {-   2                                                 -}
  46. {-  d X[1]                                             -}
  47. {-  ------  = TNTargetF1(T, X[1], X'[1], X[2], X'[2],  -}
  48. {-                       ..., X[m], X'[m]              -}
  49. {-      2                                              -}
  50. {-    dt                                               -}
  51. {-                                                     -}
  52. {- where m is the number of coupled equations.         -}
  53. {- The elements of the vector V are defined:           -}
  54. {-    V[0].X = T                                       -}
  55. {-    V[1].X = X[1]                                    -}
  56. {-    V[1].xDeriv = X'[1]                              -}
  57. {-    V[2].X = X[2]                                    -}
  58. {-    V[2].xDeriv = X'[2]                              -}
  59. {-           .                                         -}
  60. {-           .                                         -}
  61. {-           .                                         -}
  62. {-    V[m].X = X[m]                                    -}
  63. {-    V[m].xDeriv = X'[m]                              -}
  64. {-                                                     -}
  65. {-------------------------------------------------------}
  66.  
  67. var
  68.   T : Float;
  69.  
  70. begin
  71.   T := v[0].X;
  72.   TNTargetF1 := -9.8 * V[1].X / 0.6125 - 32 / 2 * (V[1].X - V[2].X);
  73. end; { function TNTargetF1 }
  74.  
  75. function TNTargetF2(V : TNvector2) : Float;
  76.  
  77. {-------------------------------------------------------}
  78. {- This is the 2nd differential equation.              -}
  79. {-                                                     -}
  80. {-   2                                                 -}
  81. {-  d X[2]                                             -}
  82. {-  ------  = TNTargetF2(T, X[1], X'[1], X[2], X'[2],  -}
  83. {-                       ..., X[m], X'[m]              -}
  84. {-      2                                              -}
  85. {-    dt                                               -}
  86. {-                                                     -}
  87. {- where m is the number of coupled equations.         -}
  88. {- The elements of the vector V are defined:           -}
  89. {-    V[0].X = T                                       -}
  90. {-    V[1].X = X[1]                                    -}
  91. {-    V[1].xDeriv = X'[1]                              -}
  92. {-    V[2].X = X[2]                                    -}
  93. {-    V[2].xDeriv = X'[2]                              -}
  94. {-           .                                         -}
  95. {-           .                                         -}
  96. {-           .                                         -}
  97. {-    V[m].X = X[m]                                    -}
  98. {-    V[m].xDeriv = X'[m]                              -}
  99. {-                                                     -}
  100. {-------------------------------------------------------}
  101.  
  102. var
  103.   T : Float;
  104.  
  105. begin
  106.   T := v[0].X;
  107.   TNTargetF2 := -9.8 * V[2].X / 0.6125 + 32 / 2 * (V[1].X - V[2].X);
  108. end; { function TNTargetF2 }
  109.  
  110. function TNTargetF3(V : TNvector2) : Float;
  111.  
  112. {-------------------------------------------------------}
  113. {- This is the third differential equation.            -}
  114. {-                                                     -}
  115. {-   2                                                 -}
  116. {-  d X[3]                                             -}
  117. {-  ------  = TNTargetF3(T, X[1], X'[1], X[2], X'[2],  -}
  118. {-                       ..., X[m], X'[m]              -}
  119. {-      2                                              -}
  120. {-    dt                                               -}
  121. {-                                                     -}
  122. {- where m is the number of coupled equations.         -}
  123. {- The elements of the vector V are defined:           -}
  124. {-    V[0].X = T                                       -}
  125. {-    V[1].X = X[1]                                    -}
  126. {-    V[1].xDeriv = X'[1]                              -}
  127. {-    V[2].X = X[2]                                    -}
  128. {-    V[2].xDeriv = X'[2]                              -}
  129. {-           .                                         -}
  130. {-           .                                         -}
  131. {-           .                                         -}
  132. {-    V[m].X = X[m]                                    -}
  133. {-    V[m].xDeriv = X'[m]                              -}
  134. {-                                                     -}
  135. {-------------------------------------------------------}
  136.  
  137. var
  138.   T : Float;
  139.  
  140. begin
  141. end; { function TNTargetF3 }
  142.  
  143. function TNTargetF4(V : TNvector2) : Float;
  144.  
  145. {-------------------------------------------------------}
  146. {- This is the fourth differential equation.           -}
  147. {-                                                     -}
  148. {-   2                                                 -}
  149. {-  d X[4]                                             -}
  150. {-  ------  = TNTargetF4(T, X[1], X'[1], X[2], X'[2],  -}
  151. {-                       ..., X[m], X'[m]              -}
  152. {-      2                                              -}
  153. {-    dt                                               -}
  154. {-                                                     -}
  155. {- where m is the number of coupled equations.         -}
  156. {- The elements of the vector V are defined:           -}
  157. {-    V[0].X = T                                       -}
  158. {-    V[1].X = X[1]                                    -}
  159. {-    V[1].xDeriv = X'[1]                              -}
  160. {-    V[2].X = X[2]                                    -}
  161. {-    V[2].xDeriv = X'[2]                              -}
  162. {-           .                                         -}
  163. {-           .                                         -}
  164. {-           .                                         -}
  165. {-    V[m].X = X[m]                                    -}
  166. {-    V[m].xDeriv = X'[m]                              -}
  167. {-                                                     -}
  168. {-------------------------------------------------------}
  169.  
  170. var
  171.   T : Float;
  172.  
  173. begin
  174. end; { function TNTargetF4 }
  175.  
  176. function TNTargetF5(V : TNvector2) : Float;
  177.  
  178. {-------------------------------------------------------}
  179. {- This is the fifth differential equation.            -}
  180. {-                                                     -}
  181. {-   2                                                 -}
  182. {-  d X[5]                                             -}
  183. {-  ------  = TNTargetF5(T, X[1], X'[1], X[2], X'[2],  -}
  184. {-                       ..., X[m], X'[m]              -}
  185. {-      2                                              -}
  186. {-    dt                                               -}
  187. {-                                                     -}
  188. {- where m is the number of coupled equations.         -}
  189. {- The elements of the vector V are defined:           -}
  190. {-    V[0].X = T                                       -}
  191. {-    V[1].X = X[1]                                    -}
  192. {-    V[1].xDeriv = X'[1]                              -}
  193. {-    V[2].X = X[2]                                    -}
  194. {-    V[2].xDeriv = X'[2]                              -}
  195. {-           .                                         -}
  196. {-           .                                         -}
  197. {-           .                                         -}
  198. {-    V[m].X = X[m]                                    -}
  199. {-    V[m].xDeriv = X'[m]                              -}
  200. {-                                                     -}
  201. {-------------------------------------------------------}
  202.  
  203. var
  204.   T : Float;
  205.  
  206. begin
  207. end; { function TNTargetF5 }
  208.  
  209. function TNTargetF6(V : TNvector2) : Float;
  210.  
  211. {-------------------------------------------------------}
  212. {- This is the sixth differential equation.            -}
  213. {-                                                     -}
  214. {-   2                                                 -}
  215. {-  d X[6]                                             -}
  216. {-  ------  = TNTargetF6(T, X[1], X'[1], X[2], X'[2],  -}
  217. {-                       ..., X[m], X'[m]              -}
  218. {-      2                                              -}
  219. {-    dt                                               -}
  220. {-                                                     -}
  221. {- where m is the number of coupled equations.         -}
  222. {- The elements of the vector V are defined:           -}
  223. {-    V[0].X = T                                       -}
  224. {-    V[1].X = X[1]                                    -}
  225. {-    V[1].xDeriv = X'[1]                              -}
  226. {-    V[2].X = X[2]                                    -}
  227. {-    V[2].xDeriv = X'[2]                              -}
  228. {-           .                                         -}
  229. {-           .                                         -}
  230. {-           .                                         -}
  231. {-    V[m].X = X[m]                                    -}
  232. {-    V[m].xDeriv = X'[m]                              -}
  233. {-                                                     -}
  234. {-------------------------------------------------------}
  235.  
  236. var
  237.   T : Float;
  238.  
  239. begin
  240. end; { function TNTargetF6 }
  241.  
  242. function TNTargetF7(V : TNvector2) : Float;
  243.  
  244. {-------------------------------------------------------}
  245. {- This is the seventh differential equation.          -}
  246. {-                                                     -}
  247. {-   2                                                 -}
  248. {-  d X[7]                                             -}
  249. {-  ------  = TNTargetF7(T, X[1], X'[1], X[2], X'[2],  -}
  250. {-                       ..., X[m], X'[m]              -}
  251. {-      2                                              -}
  252. {-    dt                                               -}
  253. {-                                                     -}
  254. {- where m is the number of coupled equations.         -}
  255. {- The elements of the vector V are defined:           -}
  256. {-    V[0].X = T                                       -}
  257. {-    V[1].X = X[1]                                    -}
  258. {-    V[1].xDeriv = X'[1]                              -}
  259. {-    V[2].X = X[2]                                    -}
  260. {-    V[2].xDeriv = X'[2]                              -}
  261. {-           .                                         -}
  262. {-           .                                         -}
  263. {-           .                                         -}
  264. {-    V[m].X = X[m]                                    -}
  265. {-    V[m].xDeriv = X'[m]                              -}
  266. {-                                                     -}
  267. {-------------------------------------------------------}
  268.  
  269. var
  270.   T : Float;
  271.  
  272. begin
  273. end; { function TNTargetF7 }
  274.  
  275. function TNTargetF8(V : TNvector2) : Float;
  276.  
  277. {-------------------------------------------------------}
  278. {- This is the eighth differential equation.           -}
  279. {-                                                     -}
  280. {-   2                                                 -}
  281. {-  d X[8]                                             -}
  282. {-  ------  = TNTargetF8(T, X[1], X'[1], X[2], X'[2],  -}
  283. {-                       ..., X[m], X'[m]              -}
  284. {-      2                                              -}
  285. {-    dt                                               -}
  286. {-                                                     -}
  287. {- where m is the number of coupled equations.         -}
  288. {- The elements of the vector V are defined:           -}
  289. {-    V[0].X = T                                       -}
  290. {-    V[1].X = X[1]                                    -}
  291. {-    V[1].xDeriv = X'[1]                              -}
  292. {-    V[2].X = X[2]                                    -}
  293. {-    V[2].xDeriv = X'[2]                              -}
  294. {-           .                                         -}
  295. {-           .                                         -}
  296. {-           .                                         -}
  297. {-    V[m].X = X[m]                                    -}
  298. {-    V[m].xDeriv = X'[m]                              -}
  299. {-                                                     -}
  300. {-------------------------------------------------------}
  301.  
  302. var
  303.   T : Float;
  304.  
  305. begin
  306. end; { function TNTargetF8 }
  307.  
  308. function TNTargetF9(V : TNvector2) : Float;
  309.  
  310. {-------------------------------------------------------}
  311. {- This is the ninth differential equation.            -}
  312. {-                                                     -}
  313. {-   2                                                 -}
  314. {-  d X[9]                                             -}
  315. {-  ------  = TNTargetF9(T, X[1], X'[1], X[2], X'[2],  -}
  316. {-                       ..., X[m], X'[m]              -}
  317. {-      2                                              -}
  318. {-    dt                                               -}
  319. {-                                                     -}
  320. {- where m is the number of coupled equations.         -}
  321. {- The elements of the vector V are defined:           -}
  322. {-    V[0].X = T                                       -}
  323. {-    V[1].X = X[1]                                    -}
  324. {-    V[1].xDeriv = X'[1]                              -}
  325. {-    V[2].X = X[2]                                    -}
  326. {-    V[2].xDeriv = X'[2]                              -}
  327. {-           .                                         -}
  328. {-           .                                         -}
  329. {-           .                                         -}
  330. {-    V[m].X = X[m]                                    -}
  331. {-    V[m].xDeriv = X'[m]                              -}
  332. {-                                                     -}
  333. {-------------------------------------------------------}
  334.  
  335. var
  336.   T : Float;
  337.  
  338. begin
  339. end; { function TNTargetF9 }
  340.  
  341. function TNTargetF10(V : TNvector2) : Float;
  342.  
  343. {-------------------------------------------------------}
  344. {- This is the tenth differential equation.            -}
  345. {-                                                     -}
  346. {-   2                                                 -}
  347. {-  d X[10]                                            -}
  348. {-  ------  = TNTargetF10(T, X[1], X'[1], X[2], X'[2], -}
  349. {-                       ..., X[m], X'[m]              -}
  350. {-      2                                              -}
  351. {-    dt                                               -}
  352. {-                                                     -}
  353. {- where m is the number of coupled equations.         -}
  354. {- The elements of the vector V are defined:           -}
  355. {-    V[0].X = T                                       -}
  356. {-    V[1].X = X[1]                                    -}
  357. {-    V[1].xDeriv = X'[1]                              -}
  358. {-    V[2].X = X[2]                                    -}
  359. {-    V[2].xDeriv = X'[2]                              -}
  360. {-           .                                         -}
  361. {-           .                                         -}
  362. {-           .                                         -}
  363. {-    V[m].X = X[m]                                    -}
  364. {-    V[m].xDeriv = X'[m]                              -}
  365. {-                                                     -}
  366. {-------------------------------------------------------}
  367.  
  368. var
  369.   T : Float;
  370.  
  371. begin
  372. end; { function TNTargetF10 }
  373. {$F-}
  374.  
  375. procedure Initialize(var NumEquations : integer;
  376.                      var LowerLimit   : Float;
  377.                      var UpperLimit   : Float;
  378.                      var InitialValue : TNvector2;
  379.                      var NumIntervals : integer;
  380.                      var NumReturn    : integer;
  381.                      var Error        : byte);
  382.  
  383. {------------------------------------------------------------------}
  384. {- Output: NumEquations, LowerLimit, UpperLimit, LowerInitial,    -}
  385. {-         InitialValues, NumIntervals, NumReturn, Error          -}
  386. {-                                                                -}
  387. {- This procedure initializes the above variables to zero.        -}
  388. {------------------------------------------------------------------}
  389.  
  390. begin
  391.   NumEquations := 0;
  392.   LowerLimit := 0;
  393.   UpperLimit := 0;
  394.   FillChar(InitialValue, SizeOf(InitialValue), 0);
  395.   NumReturn := 0;
  396.   NumIntervals := 0;
  397.   Error := 0;
  398.   Vector[1] := @TNTargetF1;
  399.   Vector[2] := @TNTargetF2;
  400.   Vector[3] := @TNTargetF3;
  401.   Vector[4] := @TNTargetF4;
  402.   Vector[5] := @TNTargetF5;
  403.   Vector[6] := @TNTargetF6;
  404.   Vector[7] := @TNTargetF7;
  405.   Vector[8] := @TNTargetF8;
  406.   Vector[9] := @TNTargetF9;
  407.   Vector[10] := @TNTargetF10;
  408. end; { procedure Initialize }
  409.  
  410. procedure GetData(var NumEquations  : integer;
  411.                   var LowerLimit    : Float;
  412.                   var UpperLimit    : Float;
  413.                   var InitialValues : TNvector2;
  414.                   var NumReturn     : integer;
  415.                   var NumIntervals  : integer);
  416.  
  417. {------------------------------------------------------------}
  418. {- Output: NumEquations, LowerLimit, UpperLimit,            -}
  419. {-         InitialValues, NumReturn, NumIntervals           -}
  420. {-                                                          -}
  421. {- This procedure assigns values to the above variables     -}
  422. {- from keyboard input                                      -}
  423. {------------------------------------------------------------}
  424.  
  425. procedure GetNumEquations(var NumEquations : integer);
  426.  
  427. {--------------------------------------}
  428. {- Output: NumEquations               -}
  429. {-                                    -}
  430. {- This procedure reads in the number -}
  431. {- of equations from the keyboard.    -}
  432. {--------------------------------------}
  433.  
  434. begin
  435.   Writeln;
  436.   repeat
  437.     Write('Number of 2nd order equations: (1-', TNRowSize, ')? ');
  438.     Readln(NumEquations);
  439.     IOCheck;
  440.   until not IOerr and (NumEquations <= TNRowSize) and (NumEquations >= 1);
  441. end; { procedure GetNumEquations }
  442.  
  443. procedure GetLimits(var LowerLimit : Float;
  444.                     var UpperLimit : Float);
  445.  
  446. {------------------------------------------------------------}
  447. {- Output: LowerLimit, UpperLimit                           -}
  448. {-                                                          -}
  449. {- This procedure assigns values to the limits of           -}
  450. {- integration from keyboard input                          -}
  451. {------------------------------------------------------------}
  452.  
  453. begin
  454.   Writeln;
  455.   repeat
  456.     repeat
  457.       Write('Lower limit of interval? ');
  458.       Readln(LowerLimit);
  459.       IOCheck;
  460.     until not IOerr;
  461.     Writeln;
  462.     repeat
  463.       Write('Upper limit of interval? ');
  464.       Readln(UpperLimit);
  465.       IOCheck;
  466.     until not IOerr;
  467.     if LowerLimit = UpperLimit then
  468.     begin
  469.       Writeln;
  470.       Writeln('       The limits of integration must be different.');
  471.       Writeln;
  472.     end;
  473.   until LowerLimit <> UpperLimit;
  474. end; { procedure GetLimits }
  475.  
  476. procedure GetInitialValues(NumEquations  : integer;
  477.                            LowerLimit    : Float;
  478.                        var InitialValues : TNvector2);
  479.  
  480. {--------------------------------------------------}
  481. {- Input: NumEquations, LowerLimit                -}
  482. {- Output: InitialValues                          -}
  483. {-                                                -}
  484. {- This procedure assigns values to InitialValues -}
  485. {- from keyboard input.                           -}
  486. {--------------------------------------------------}
  487.  
  488. var
  489.   Term : integer;
  490.  
  491. begin
  492.   InitialValues[0].X := LowerLimit;
  493.   Writeln;
  494.   for Term := 1 to NumEquations do
  495.   begin
  496.     repeat
  497.       Write('Enter  X[', Term, '] value at t =', LowerLimit : 14, ': ');
  498.       Readln(InitialValues[Term].X);
  499.       IOCheck;
  500.     until not IOerr;
  501.     repeat
  502.       Write('Enter X''[', Term, '] value at t =', LowerLimit : 14, ': ');
  503.       Readln(InitialValues[Term].xDeriv);
  504.       IOCheck;
  505.     until not IOerr;
  506.   end;
  507. end; { procedure GetInitialValues }
  508.  
  509. procedure GetNumReturn(var NumReturn : integer);
  510.  
  511. {----------------------------------------------------------}
  512. {- Output: NumReturn                                      -}
  513. {-                                                        -}
  514. {- This procedure reads in the number of values to return -}
  515. {- in the vectors TValues, XValues and XDerivValues.      -}
  516. {----------------------------------------------------------}
  517.  
  518. begin
  519.   Writeln;
  520.   repeat
  521.     Write('Number of values to return (1-', TNColumnSize, ')? ');
  522.     Readln(NumReturn);
  523.     IOCheck;
  524.   until not IOerr and (NumReturn <= TNColumnSize) and (NumReturn >= 1);
  525. end; { procedure GetNumReturn }
  526.  
  527. procedure GetNumIntervals(NumReturn    : integer;
  528.                       var NumIntervals : integer);
  529.  
  530. {------------------------------------------------------------}
  531. {- Input: NumReturn                                         -}
  532. {- Output: NumIntervals                                     -}
  533. {-                                                          -}
  534. {- This procedure reads in the number of intervals          -}
  535. {- over which to solve the equation.                        -}
  536. {------------------------------------------------------------}
  537.  
  538. begin
  539.   Writeln;
  540.   NumIntervals := NumReturn;
  541.   repeat
  542.     Write('Number of intervals (>= ', NumReturn, ')? ');
  543.     ReadInt(NumIntervals);
  544.     IOCheck;
  545.     if NumIntervals < NumReturn then
  546.     begin
  547.       IOerr := true;
  548.       NumIntervals := NumReturn;
  549.     end;
  550.   until not IOerr;
  551. end; { procedure GetNumIntervals }
  552.  
  553. begin { procedure GetData }
  554.   GetNumEquations(NumEquations);
  555.   GetLimits(LowerLimit, UpperLimit);
  556.   GetInitialValues(NumEquations, LowerLimit, InitialValues);
  557.   GetNumReturn(NumReturn);
  558.   GetNumIntervals(NumReturn, NumIntervals);
  559.   GetOutputFile(OutFile);
  560. end; { procedure GetData }
  561.  
  562. procedure Results(NumEquations   : integer;
  563.                   LowerLimit     : Float;
  564.                   UpperLimit     : Float;
  565.                   InitialValues  : TNvector2;
  566.                   NumIntervals   : integer;
  567.                   NumReturn      : integer;
  568.               var SolutionValues : TNmatrix2;
  569.                   Error          : byte);
  570.  
  571. {------------------------------------------------------------}
  572. {- This procedure outputs the results to the device OutFile -}
  573. {------------------------------------------------------------}
  574.  
  575. var
  576.   Term : integer;
  577.   Index : integer;
  578.  
  579. begin
  580.   Writeln(OutFile);
  581.   Writeln(OutFile);
  582.   Writeln(OutFile, 'Lower Limit:' : 35, LowerLimit);
  583.   Writeln(OutFile, 'Upper Limit:' : 35, UpperLimit);
  584.   Writeln(OutFile, 'Number of intervals:' : 35, NumIntervals);
  585.   Writeln(OutFile, 'Initial conditions at lower limit:' : 35);
  586.   for Term := 1 to NumEquations do
  587.   begin
  588.     Writeln(OutFile, ' X[' : 21, Term,']= ', InitialValues[Term].X);
  589.     Writeln(OutFile, 'X''[': 21, Term,']= ', InitialValues[Term].xDeriv);
  590.   end;
  591.   Writeln(OutFile);
  592.   if Error >= 1 then
  593.     DisplayError;
  594.  
  595.   case Error of
  596.     0 : begin
  597.           for Term := 1 to NumEquations do
  598.           begin
  599.             Writeln(OutFile, 't':10, 'Value X[' : 30, Term, ']',
  600.                              'Deriv X[' : 28, Term, ']');
  601.             for Index := 0 to NumReturn do
  602.               Writeln(OutFile, SolutionValues[Index, 0].X : 15 : 8,
  603.                                SolutionValues[Index, Term].X : 30,
  604.                                SolutionValues[Index, Term].xDeriv : 30);
  605.             Writeln(OutFile);
  606.           end;
  607.         end;
  608.  
  609.     1 : Writeln(OutFile,
  610.                 'The number of values to return must be greater than zero.');
  611.     2 : begin
  612.           Writeln(OutFile, 'The number of intervals must be greater than');
  613.           Writeln(OutFile, 'or equal to the number of values to return.');
  614.         end;
  615.  
  616.     3 : Writeln(OutFile,
  617.                 'The number of equations must be greater than zero.');
  618.     4 : Writeln(OutFile, 'The lower limit must be different ',
  619.                          'from the upper limit.');
  620.   end;
  621. end; { procedure Results }
  622.  
  623. begin { program InitialConditionSystem2 }
  624.   ClrScr;
  625.   Initialize(NumEquations, LowerLimit, UpperLimit, InitialValues,
  626.              NumIntervals, NumReturn, Error);
  627.   GetData(NumEquations, LowerLimit, UpperLimit, InitialValues,
  628.           NumReturn, NumIntervals);
  629.   InitialConditionSystem2(NumEquations, LowerLimit, UpperLimit, InitialValues,
  630.                           NumReturn, NumIntervals, SolutionValues, Error, Vector);
  631.   Results(NumEquations, LowerLimit, UpperLimit, InitialValues, NumIntervals,
  632.           NumReturn, SolutionValues, Error);
  633.   Close(OutFile);
  634. end. { program InitialConditionSystem2 }
  635.