slegtrte.pas 3.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162
  1. program slegtrte;
  2. uses
  3. typ,
  4. iom,
  5. sle;
  6. const
  7. m1 = -10;
  8. m2 = 10;
  9. type
  10. array1dr = array[m1..m2] of ArbFloat;
  11. var
  12. k, nex, ex, i, n, term: ArbInt;
  13. ca: ArbFloat;
  14. l, d, u, b, x: array1dr;
  15. begin
  16. Write('program results slegtrte ');
  17. case SizeOf(ArbFloat) of
  18. 4: writeln('(single)');
  19. 8: writeln('(double)');
  20. 6: writeln('(real)');
  21. end;
  22. Read(nex);
  23. writeln;
  24. writeln(' number of examples : ', nex: 2);
  25. for ex := 1 to nex do
  26. begin
  27. writeln;
  28. writeln(' example number :', ex: 2);
  29. writeln;
  30. Read(n, k);
  31. iomrev(input, l[k + 1], n - 1);
  32. iomrev(input, d[k], n);
  33. iomrev(input, u[k], n - 1);
  34. iomrev(input, b[k], n);
  35. slegtr(n, l[k + 1], d[k], u[k], b[k], x[k], ca, term);
  36. writeln;
  37. writeln(' l (lower diagonal of A) = ');
  38. iomwrv(output, l[k + 1], n - 1, numdig);
  39. writeln;
  40. writeln(' d (main diagonal of A) =');
  41. iomwrv(output, d[k], n, numdig);
  42. writeln;
  43. writeln(' u (upper diagonal of A) =');
  44. iomwrv(output, u[k], n - 1, numdig);
  45. writeln;
  46. writeln(' A =');
  47. for i := 1 to n do
  48. begin
  49. if i > 1 then
  50. Write('': (i - 2) * (numdig + 2), l[k + i - 1]: numdig, '': 2);
  51. Write(d[k + i - 1]: numdig, '': 2);
  52. if i < n then
  53. Write(u[k + i - 1]: numdig);
  54. writeln;
  55. end;
  56. writeln;
  57. writeln(' b =');
  58. iomwrv(output, b[k], n, numdig);
  59. writeln;
  60. writeln('term=', term: 2);
  61. case term of
  62. 1:
  63. begin
  64. writeln('x=');
  65. iomwrv(output, x[k], n, numdig);
  66. writeln;
  67. writeln(' ca = ', ca: 12);
  68. end;
  69. 2: writeln('solution not possible');
  70. 3: writeln(' wrong value of n');
  71. end;
  72. writeln('-----------------------------------------------');
  73. end; {example}
  74. Close(input);
  75. Close(output);
  76. end.
  77. program slegtrte;
  78. uses
  79. typ,
  80. iom,
  81. sle;
  82. const
  83. m1 = -10;
  84. m2 = 10;
  85. type
  86. array1dr = array[m1..m2] of ArbFloat;
  87. var
  88. k, nex, ex, i, n, term: ArbInt;
  89. ca: ArbFloat;
  90. l, d, u, b, x: array1dr;
  91. begin
  92. Write('program results slegtrte ');
  93. case SizeOf(ArbFloat) of
  94. 4: writeln('(single)');
  95. 8: writeln('(double)');
  96. 6: writeln('(real)');
  97. end;
  98. Read(nex);
  99. writeln;
  100. writeln(' number of examples : ', nex: 2);
  101. for ex := 1 to nex do
  102. begin
  103. writeln;
  104. writeln(' example number :', ex: 2);
  105. writeln;
  106. Read(n, k);
  107. iomrev(input, l[k + 1], n - 1);
  108. iomrev(input, d[k], n);
  109. iomrev(input, u[k], n - 1);
  110. iomrev(input, b[k], n);
  111. slegtr(n, l[k + 1], d[k], u[k], b[k], x[k], ca, term);
  112. writeln;
  113. writeln(' l (lower diagonal of A) = ');
  114. iomwrv(output, l[k + 1], n - 1, numdig);
  115. writeln;
  116. writeln(' d (main diagonal of A) =');
  117. iomwrv(output, d[k], n, numdig);
  118. writeln;
  119. writeln(' u (upper diagonal of A) =');
  120. iomwrv(output, u[k], n - 1, numdig);
  121. writeln;
  122. writeln(' A =');
  123. for i := 1 to n do
  124. begin
  125. if i > 1 then
  126. Write('': (i - 2) * (numdig + 2), l[k + i - 1]: numdig, '': 2);
  127. Write(d[k + i - 1]: numdig, '': 2);
  128. if i < n then
  129. Write(u[k + i - 1]: numdig);
  130. writeln;
  131. end;
  132. writeln;
  133. writeln(' b =');
  134. iomwrv(output, b[k], n, numdig);
  135. writeln;
  136. writeln('term=', term: 2);
  137. case term of
  138. 1:
  139. begin
  140. writeln('x=');
  141. iomwrv(output, x[k], n, numdig);
  142. writeln;
  143. writeln(' ca = ', ca: 12);
  144. end;
  145. 2: writeln('solution not possible');
  146. 3: writeln(' wrong value of n');
  147. end;
  148. writeln('-----------------------------------------------');
  149. end; {example}
  150. Close(input);
  151. Close(output);
  152. end.