Деление комплексных чисел

Частное двух комплексных чисел Z = Xi + iyi и Z2 = Х2 + гу2 можно вычислить по формуле

Z1 _ ZjZ^ _ (xi +м/1)(д?2 -гу₂) _ #1^2 + У1У2 ₊ -У1Х₂ - ХгУ2

Z2 Z₂Zi Х2² + У2² Х2² + У2² Х₂² + У2²

• а) Напишите программу на языке PASCAL-XSC, которая содержит декларацию операции Cdiv, реализующей деление двух комплексных чисел типа complex с помощью операций +, — , *, / для чисел типа real. В главной программе считываются два числа типа complex, вычисляется и выводится на печать их частное.
• б) Подключите к вашей программе модуль C_ARI. Вычислите то же частное с помощью определенной в этом модуле операции / и сравните результаты.
• в) Проверьте вашу программу на значениях z = Xi+iyi и z₂ = Х2 + iy₂, где

X! = 1254027132096, _У1 = 886731088897,

Х2 = 886731088897, у₂ = 627013566048.

При этом в мнимых частях результатов должны наблюдаться очевидные расхождения.

г) Определите еще одну операцию NewCdiv, дающую лучший результат благодаря использованию высокоточных выражений. Сравните все три операции.

Решение

program ComplDiv (input, output);

{ Упражнение 13. Деление комплексных чисел }

use c_ari;

var zl, z2 : complex;

priority Cdiv = *;

operator Cdiv (zl, z2 : complex) result : complex;

var denom : real;

begin

denom := sqr(z2.re) + sqr(z2.im);

result.re:= (zl.re*z2.re + zl.im*z2.im)/denom;

result.im:= (z2.re*zl.im - zl.re*z2.im)/denom;

end;

priority NewCdiv = *;

operator NewCdiv (zl, z2 : complex) NewResult : complex; var denom : real;

begin

denom := #*(z2.re*z2.re + z2.im*z2.im);

NewResult.re:= #*(zl.re*z2.re + zl.im*z2.im)/denom;

NewResult.im:= #*(z2.re*zl.im - zl.re*z2.im)/denom; end;

begin

writein (’Exercise 13: Complex Division’);

writein;

write (’Numerator zl = ’); read (zl);

write (’Denominator z2 = ’); read (z2);

writein;

Вывод времени выполнения

Exercise 13: Complex Division

Numerator zl = ( 1254027132096, 886731088897 )

Denominator z2 = ( 886731088897, 627013566048 )

zl Cdiv z2 = ( 1.414213562373095E+000, 0.000000000000000E+000 )

zl NewCdiv z2 = ( 1.414213562373095E+000, 8.478614131951457E-025 )

zl / z2 = ( 1.414213562373095E+000, 8.478614131951457E-025 )

Упражнение 14. Расчет электрической цепи

От одной до трех ламп с сопротивлением R = 240 Ом параллельно подключаются к источнику напряжения U = 220 В через линию длиной I — 100 м, сделанную из провода диаметром d — 1.5 мм и удельным сопротивлением р = 0.02857 Ом-мм²/м. Все величины измерены с погрешностью 0.5%.

Требуется написать программу на языке PASCAL-XSC, использующую модуль I_ARI и тип interval. Для случаев включения одной, двух и трех ламп (n = 1, 2, 3) необходимо вычислить интервалы, в которых заключены значения Ri₀[ (общее сопротивление цепи), I[_Oi (общий потребляемый ток),

U_w (падение напряжения на проводах) и Ubu (падение напряжения на лампах). Используйте следующие формулы:

Rtot ⁼ Rw И^- R/и,

Rot — U/ Rtot,

Uw — R_w' Rot,

u_bll = U-U_w.

Ваша программа должна:

• 1) прочитать значения тг, R, I, d, р, U, вычислить, используя значение погрешности 0.5%, интервалы R, L, D, Rho и U, включающие данные значения, а также интервал PI, включающий значение тг, и напечатать значения этих интервалов;
• 2) вычислить и напечатать включающий интервал Rw сопротивления линии

R_w = (8 • р • /)/(тг • с/²);

• 3) вычислить и напечатать интервалы Rt_ot (общее сопротивление цепи), Rot (общий потребляемый ток), U_w (падение напряжения на проводах) и Ubu (падение напряжения на лампах) для значений п = 1, 2, 3;
• 4) напечатать интервал Us, представляющий собой общий диапазон значений напряжения на лампах для различного числа включенных ламп.

Подсказка. Включающий интервал PI для значения 7Г можно вычислить с помощью соотношения

= 4 • arctg([l, 1]).

Используйте предопределенный тип interval и модуль I_ARI, содержащий необходимые интервальные операции.

Решение

program circuit (input, output);

{ Упражнение 14. Расчет электрической цепи }

use i_ari;

var error, U, L, D, Rho, R, Us, pi, Rw, Rtot, Itot, Uw, Ubu : interval; n : integer; procedure write (var f: text; int: interval; long: boolean);

{ Совмещение процедуры write для вывода интервалов с }

{ длинной мантиссой. Вывод интервалов по умолчанию } { производится в соответствии с шириной интервала. } begin

if long then

write (f,’[’,int.inf:20:0:-1 ,’,’,int.sup:20:0:+l ,’]’) { Вывод с большим количеством цифр }

else

write (f,int);

{ Стандартная процедура вывода из модуля I_ARI } end;

begin

pi := 4 * arctan (intval(l));

error := intval ( (<0.995) , (>1.005) );

r := r * error;

1 := 1 * error;

d := d * error;

Rho:= Rho * error;

u := u * error;

writein;

writein (’Intervals:’);

writein (’PI = ’,pi : true);

writein (’R = ’,R : true);

writein (’L = ’ ,L : true);

writein (’D = ’,D : true);

writein (’Rho = ’,Rho: true);

writein (’U = ’,U : true);

writein;

Rw:= (8*Rho*L)/(pi*sqr(D));

writein (’Inclusion of the wire resistance:’);

writein (’Rw = ’,Rw : true);

for n:= 1 to 3 do

begin

writein;

Rtot:= Rw + r/n;

Itot:= U / Rtot;

Uw := Rw * Itot;

Ubu := U - Uw;

if n = 1 then

Us:= Ubu

else

Us: = Us +* Ubu;

write(’With ’,n:l,’ bulb’);

if n <> 1 then write (’s’);

writeln(’, the following inclusions are computed:’);

writeln(’- total resistance: Rtot = ’,Rtot : true);

writeln(’- total current: Itot = ’,Itot : true);

writeln(’- wire voltage: Uw = ’ ,Uw : true);

writeln(’- bulb voltage: Ubu = ’ ,Ubu : true);

write(’press return’); readln; writein;

end;

writein (’The bulb voltage Ubu has the total range interval’); writein (Us : true);

end.

Вывод времени выполнения

Exercise 14: Electric Circuit

U = 220

1 = 100

d =1.5

rho = 0.02857

R = 240

Intervals:

PI = [ 3.141592653589E+000, 3.141592653590E+000] R = [ 2.387999999999E+002, 2.412000000001E+002] L = [ 9.949999999999E+001, 1.005000000001E+002] D = [ 1.492499999999E+000, 1.507500000001E+000] Rho = [ 2.842714999999E-002, 2.871285000001E-002] U = [ 2.188999999999E+002, 2.211000000001E+002]

Inclusion of the wire resistance:

Rw = [ 3.169435182649E+000, 3.298783385817E+000]

With 1 bulb, the following inclusions are computed:

• - total resistance: Rtot = [ 2.419694351826E+002, 2.444987833859E+002]
• - total current: Itot = [ 8.953009784698E-001, 9.137517713058E-001]
• - wire voltage: Uw = [ 2.837598420222E+000, 3.014269161944E+000]
• - bulb voltage: Ubu = [ 2.158857308380E+002, 2.182624015798E+002]

press return

With 2 bulbs, the following inclusions are computed:

• - total resistance: Rtot = [ 1.225694351826E+002, 1.238987833859E+002]
• - total current: Itot = [ 1.766764725351E+000, 1.803875490416E+000]
• - wire voltage: Uw = [ 5.599646279992E+000, 5.950594497863E+000]
• - bulb voltage: Ubu = [ 2.129494055021E+002, 2.155003537201E+002]

press return

With 3 bulbs, the following inclusions are computed:

• - total resistance: Rtot = [ 8.276943518264E+001, 8.369878338582E+001]
• - total current: Itot = [ 2.615330726982E+000, 2.671275930688E+000]
• - wire voltage: Uw = [ 8.289121220362E+000, 8.811960659084E+000]
• - bulb voltage: Ubu = [ 2.100880393409E+002, 2.128108787797E+002]

press return

The bulb voltage Ubu has the total range interval [ 2.100880393409E+002, 2.182624015798E+002]

Упражнение 15. Мост для измерения переменного тока

Неизвестные значения емкости конденсатора C*i и сопротивления резистора Ri можно измерить с помощью показанной схемы. Если, изменяя емкость С2 и сопротивление R?, добиться минимума громкости звука (или даже тишины) в громкоговорителе К, то емкости и сопротивления будут удовлетворять соотношениям

С = Ri-Cz/Ri, Ri = R3 • R2 /Ri ?

По данным изготовителя,

значения сопротивлений 7?з и R4 находятся в

диапазонах

• 9.9 Ом
• 6.8 Ом

R-з

R4

• 10.1 Ом,
• 6.9 Ом.

Учитывая погрешности измерения, мы получим следующие оценки для С2 и R₂:

• 40.2 мкФ
• 18.3 Ом

С₂

R2

• 41.5 мкФ,
• 19.8 Ом.

Требуется написать программу на языке PASCAL-XSC, которая

• • считывает границы значений R3, R4, С2 и
• • вычисляет и печатает интервальные включения значений Ci и Ri;
• • повторяет вычисление включений в предположении, что погрешность измерения значений С2 и R2 больше на 10%.

Подсказка. Увеличение погрешности измерений С2 и R2 на 10% интерпретируется как увеличение на 10% радиуса соответствующих интер

валов.

Решение

program measure_bridge (input, output);

{ Упражнение 15. Мост для измерения переменного тока } use i_ari;

var

cl, c2, rl, r2, r3, r4 : interval;

d : real;

procedure write (var f: text; int: interval; long: boolean);

{ Совмещение процедуры write для вывода интервалов с }

{ длинной мантиссой. Вывод интервалов по умолчанию }

{ производится в соответствии с шириной интервала. } begin

if long then

write (f , ’ [’,int.inf:20:0:-1 , ’,’,int.sup:20:0:+l ,’]’)

{ Вывод с большим количеством цифр. }

else

write (f,int);

{ Стандартная процедура вывода из модуля I_ARI. } end;

begin

writein (’Exercise 15: Alternating Current Measuring Bridge’);

writein;

write(’lower bound of R3: ’); read(r3.inf:-1);

write(’upper bound of R3: ’); read(r3.sup:+1);

write(’lower bound of R4: ’); read(r4.inf:-1);

write(’upper bound of R4: ’); read(r4.sup:+1);

write(’lower bound of C2: ’); read(c2.inf:-1);

write(’upper bound of C2: ’); read(c2.sup:+1);

write(’lower bound of R2: ’); read(r2.inf:-1);

write(’upper bound of R2: ’); read(r2.sup:+1);

{ Вычисление Cl и Rl }

cl:= r4 * c2 / r3;

rl:= r3 * r2 / r4;

writein;

writeln(’Cl = ’, cl : true);

writeln(’Rl = ’, rl : true);

{ Вычисление 107. радиуса, т. e. 1/20 диаметра. } d := diam(c2) /> 20;

{ Увеличение интервального радиуса на эту величину. } с2:= intval ( c2.inf -< d , c2.sup +> d );

{ Вычисление 107. радиуса, т. е. 1/20 диаметра. } d := diam(r2) /> 20;

{ Увеличение интервального радиуса на эту величину. } r2:= intval ( r2.inf -< d , r2.sup +> d );

{ Вычисление Cl и Rl } cl:= r4 * c2 / r3;

rl:= r3 * r2 / r4;

writein;

writeln(’Results, with the error for C2 and R2 107. higher:’);

writein;

writeln(^JCl = ’ , cl : true);

writeln(’Rl = ’, rl : true); end.

Вывод времени выполнения

Exercise 15: Alternating Current Measuring Bridge lower bound of R3: 9.9 upper bound of R3: 10.1 lower bound of R4: 6.8 upper bound of R4: 6.9 lower bound of C2: 40.2 upper bound of C2: 41.5 lower bound of R2: 18.3 upper bound of R2: 19.8

Cl = [ 2.706534653465E+001, 2.892424242425E+001]

Rl = [ 2.625652173913E+001, 2.940882352942E+001]

Results, with the error for C2 and R2 107, higher:

Cl = [ 2.702158415841E+001, 2.896954545455E+001]

Rl = [ 2.614891304347E+001, 2.952022058824E+001]

Замечание. Этот пример демонстрирует удобство применения интервальной арифметики для оценки погрешностей в инженерных расчетах.

Упражнение 16. Оптическая линза

Для линзы с фокусным расстоянием /=(20±1)см измерено расстояние до изображения В объекта G, равное b = (25 ± 1) см. Уравнение тонкой линзы для определения расстояния до объекта д имеет следующий вид:

• 111
• 7 — 7 + “•

f Ь д

Отсюда находим выражение для д:

1

^д = ТТг

f ь

Обычно значение д = до ± Лд вычисляется с приближением до и максимальной величиной погрешности /д с помощью формулы

• 1
• 9° = ±_j_ fo ъ_о

и линеаризации

л А/ А6

Да =----4--h -г------.

(1- (>-1)²

^v bo' ⁴ Jo ’

Пусть /о = 20 см, Ьо = 25 см и Д/ = Д6 = 1 см. Требуется написать программу на языке PASCAL-XSC, которая:

• • считывает значения fo, bo, и Д5;
• • вычисляет интервал д = до ± /д описанным выше методом;
• • вычисляет интервал д на основании интервалов f и Ь, используя интервальную арифметику, по формуле
• 1
• 9 = ТТТ^; f ь
• • печатает /, b и два различных значения д с соответствующими комментариями.

Дает ли обычный метод правильный результат? Сравните полученный результат с включением для д, полученным с помощью интервальной арифметики.

Решение program opt_lens (input, output);

{ Упражнение 16. Оптическая линза } use i_ari;

var

gO, dg, fO, df, bO, db : real;

g, f, b : interval;

procedure write (var f: text; int: interval; long: boolean);

{ Совмещение процедуры write для вывода интервалов с }

{ длинной мантиссой. Вывод интервалов по умолчанию } { производится в соответствии с шириной интервала. } begin

if long then

write (fint.inf:20:0:-1 , ’,’,int.sup:20:0:+l ,’]’) { Вывод с большим количеством цифр. }

else write (f,int);

{ Стандартная процедура вывода из модуля I_ARI. } end;

begin

writein (’Exercise 16: Optical Lens’);

writein;

write(’fO = ’); read(fO);

write(’df = ’); read(df);

write(’bO = ’); read(bO);

write(’db = ’); read(db);

writein;

f: = intval (fO - df , fO + df);

b:= intval (bO - db , bO + db);

writein (’f = ’, f : true);

writein (’b = ’, b : true);

writein;

gO := 1 / (1/fO - 1/bO);

dg := df / sqr(l - fO/bO) + db / sqr(bO/fO - 1);

g := intval (gO - dg , gO + dg);

writein (’g = gO +/- dg = ’, g : true);

g:= l/(l/f - 1/b);

writein (’g = 1 / (1/f - 1/b) = ’, g : true); end.

Вывод времени выполнения

Exercise 16: Optical Lens

fO = 20

df = 1

bO = 25

db = 1

f = [ 1.900000000000E+001, 2.100000000000E+001]

b = [ 2.400000000000E+001, 2.600000000000E+001]

g = gO +/- dg = [ 5.899999999999E+001, 1.410000000000E+002]

g = 1 / (1/f - 1/b) = [ 7.057142857142E+001, 1.680000000001E+002]

Замечание 1. Метод, обычно используемый для оценки погрешности, дает неверный результат.

Замечание 2. Упражнения 14, 15 и 16 были подготовлены под влиянием статьи: Р. Thieler. Technical Calculations by Means of Interval Mathematics

[54].

Упражнение 17. Интервальное вычисление полинома

Требуется написать программу на языке PASCAL-XSC, использующую модуль I_AR1, для вычисления полинома

р(Х) = 1 + ЗХ - 10Х²

с применением интервальной арифметики. Сравните результаты для следующих представлений полинома [X принадлежит к типу interval):

• 1) (1 — 2 * X) * (1 + 5 * X);
• 2) 1 + 3*Х — 10* sqr(X);
• 3) 1 + X * (3 — 10 * X) (схема Гориера);
• 4) 1 + 3 * т(Х) - 10 * sqr(m(X)) + (3 - 20 * X) (X - т(Х)) (центрированная форма [49], где т(Х) есть средняя точка интервала X).

Как примеры значений X, задайте сначала минимальные интервалы (с разностью границ в одну единицу 14-го разряда), а затем интервалы с другими диаметрами. Проверьте также программу на интервалах в окрестности нулей данного полинома (х = 0.5 и х = —0.2) и в окрестности его экстремума (х = 0.15).

Подсказка. Для вычисления средней точки интервала с максимальной точностью напишите функцию, использующую # -выражение.

Решение

program int_poly (input, output);

{ Упражнение 17. Интервальное вычисление полинома }

use i_ari;

var х : interval;

function midpoint (x : interval) : real;

begin

midpoint:= #* (0.5 * x.inf +0.5 * x.sup); end;

begin

writein (’Exercise 17: Interval Evaluation of a Polynomial’);

writein;

repeat

write (’Enter X : ’); read(x); writein;

writein (’Method 1: p(X) = ’, writein (’Method 2: p(X) = ’, writein (’Method 3: p(X) = ’, writein (’Method 4: p(X) = ’,

(l-2*x)*(l+5*x));

l+3*x-10*sqr(x));

1+x*(3-10*x));

l+3*midpoint(x)

-10*sqr(midpoint(x))

+(3-20*x)*(x-midpoint(x)));

writein; writein; until x = 0;

end.

Вывод времени выполнения

Exercise 17: Interval Evaluation of a Polynomial

Enter X : [0.5,0.5]

Method 1: p(X) = [

Method 2: p(X) = [ Method 3: p(X) = [ Method 4: p(X) = [

• 0.000000000000000E+000, 0.000000000000000E+000, 0.000000000000000E+000, 0.000000000000000E+000,
• 0.000000000000000E+000]
• 0.000000000000000E+000]
• 0.000000000000000E+000]
• 0.000000000000000E+000]

Enter X : [0.4999999999,0.5]

Enter X : [-0.2000000000001,-0.1999999999999]

Method 1:

Method 2:

Method 3:

Method 4:

p(X) = [ p(X) = [ p(X) = [ p(X) = [

• -7.1E-013,
• -7.1E-013,
• -7.1E-013,
• -7.1E-013,
• 7.1E-013]
• 7.1E-013]
• 7.1E-013]
• 7.1E-013]

Enter X : [0.1499999999999,0.1500000000001]

Method 1: p(X) = [ Method 2: p(X) = [ Method 3: p(X) = [ Method 4: p(X) = [

• 1.224999999999E+000,
• 1.224999999999E+000,
• 1.224999999999E+000,
• 1.224999999999999E+000,
• 1.225000000001E+000] 1.225000000001E+000] 1.225000000001E+000] 1.225000000000001E+000]

Enter X : [0.1,0.2]

Enter X : 0

Method 1: p(X) = [ Method 2: p(X) = [ Method 3: p(X) = [ Method 4: p(X) = [

• 1.000000000000000E+000, 1.000000000000000E+000, 1.000000000000000E+000, 1.000000000000000E+000,
• 1.000000000000000E+000]
• 1.000000000000000E+000]
• 1.000000000000000E+000]
• 1.000000000000000E+000]

Упражнение 18. Вычисления с интервальными матрицами

Пусть заданы две интервальные матрицы А и В:

,_Ш [0,1] Л-1,2] [3,4]

[Г1] [-1.1] J’ к [2,2] [-6,-4] J'

Напишите программу, которая:

• а) вычисляет А + В, А — В, А х В;
• б) показывает (с помощью вычислений), что Ах (Ах х А) х А;
• в) показывает (с помощью вычислений), что Ах (В + А) ^АхВ + АхА и Ах (В + А) с А х В + А х А.

Подсказка. Используйте операции из модуля MVI_ARI.

Решение

program intjmatr (input, output);

{ Упражнение 18. Вычисления с интервальными матрицами }

use i_ari, mvi_ari;

var

А, В, С : imatrix[1..2,1..2] ;

begin

writein (’Exercise 18: Calculations for Interval Matrices’); writein;

A[1,1]:= 1;

A[l,2] : = intval(0,l);

A[2,1]:= 1;

A[2,2]:= intval(-l,1);

B[l,l]: = intval(-l,2);

В[1,2]:= intval(3,4);

В[2,1]:= 2;

В[2,2]:= intval(-6,-4);

writein (А*(А*А));

writein (’(А * А) * А = ’); writein;

writein ((А*А)*А);

writein (’А * (В + А) = ’); writein;

writein (А*(В+А));

writein (’А * В + А* А = ’); writein;

writein (А*В+А*А);

end.

Вывод времени выполнения

Exercise 18: Calculations for Interval Matrices

[ 1.0E+00, 1.0E+00] [ 0.0E+00, 1.0E+00]

[ 1.0E+00, 1.0E+00] [-1.0E+00, 1.0E+00]

В =

[-1.0E+00, 2.0E+00] [ 3.0E+00, 4.0E+00] [ 2.0E+00, 2.0E+00] [-6.0E+00.-4.0E+00]

A + В = [ 0.0E+00, 3.0E+00] [ 3.0E+00, 5.0E+00] [ 3.0E+00, 3.0E+00] [-7.0E+00.-3.0E+00]

A - В = [-1.0E+00, 2.0E+00] [-4.0E+00,-2.0E+00] [-1.0E+00,-1.0E+00] [ 3.0E+00, 7.0E+00]

A * В = [-1.0E+00, 4.0E+00] [-3.0E+00, 4.0E+00] [-3.0E+00, 4.0E+00] [-3.0E+00, 1.0E+01]

A * (A * A) = [ 1.0E+00, 4.0E+00] [-2.0E+00, 4.0E+00] [-1.0E+00, 4.0E+00] [-3.0E+00, 4.0E+00]

(A * A) * A = [ 0.0E+00, 4.0E+00] [-2.0E+00, 4.0E+00] [-1.0E+00, 4.0E+00] [-2.0E+00, 4.0E+00]

A * (B + A) =

[ 0.0E+00, 6.0E+00] [-4.0E+00, 5.0E+00]

[-3.0E+00, 6.0E+00] [-4.0E+00, 1.2E+01]

A*B + A*A = [ 0.0E+00, 6.0E+00][-4.0E+00, 6.0E+00]

[-3.0E+00, 6.0E+00][-4.0E+00, 1.2E+01]

Упражнение 19. Дифференциальная арифметика

С помощью дифференциальной арифметики (см. [48]) вычислить значения функции и значения ее производной f'(x) на интервале — 4 С х С 2 для точек Хк = = — 4 + kh, к = 0,..., 48, где h = 0.125.

Дифференциальная арифметика — арифметика упорядоченных пар

U = (u,w^x), где и,и' Е JR.

Первая компонента U содержит значение функции, вторая — значение ее производной. Для этих элементов вводятся следующие операции:

U + V = (и, и') + (v, v') = (и + v, и' + v'),

U— V = (и, и ) — (у, v') = (у — v,u'— г/),

U * V — (и, г?) * (щ г/) — (и * v, и * v' + и' * v),

U/V = (щ m')/(v, г>') = (u/v, (и¹ — u/v * v'/v), v 7^ 0,

где для вычисления второй компоненты применяются соответствующие правила дифференцирования. Независимая переменная х и произвольная константа с представляются как

X — (х, 1) и С — (с, 0),

поскольку = 1 и = 0. Для реализации дифференциальной арифметики в программе на PASCAL-XSC необходимо объявить тип Derivative _Туре, являющийся записью из двух компонент типа real. Затем нужно определить функцию f с параметрами и результатом типа Derivative _Туре, а также операции дифференциальной арифметики +, —, *, /. Если

/(Х) = Х*((4,0) + Х)/((3,0)-Х),

то автоматическое дифференцирование обеспечивается тем, что

/(Х) = /((_Ж,1)) = (Щ),/'(_Ж)).

Иными словами, значение функции и ее производной вычисляются автоматически и одновременно. Напишите модуль на языке PASCAL-XSC, содержащий

• а) декларацию типа Derivative_Type;
• б) декларации операций +,—,*,/ в соответствии с приведенными правилами.

Напишите программу на языке PASCAL-XSC, включающую а) процедуру-функцию F, которая с помощью операций из модуля вычисляет значение функции и ее производной;

б) главную программу, вычисляющую и табулирующую значения f(x) и f'(x) в указанных точках.

Подсказка. Константы 4 и 3, принадлежащие к типу Derivative _Туре, представляются как (4,0) и (3,0) соответственно. Независимая переменная х представляется как (Ф, 1).

Решение

module diff_ari;

{ Упражнение 19. Модуль дифференциальной арифметики }

global type Derivative_Type = global record

f, df : real;

end;

global operator := (var a: Derivative_Type; r: real);

begin

a.f := r;

a.df := 0;

end;

global operator + (a,b: Derivative_Type) Result_add: Derivative_Type;

begin

Result_add.f := a.f + b.f;

Result_add.df := a.df + b.df;

end;

global operator - (a,b: Derivative_Type) Result_sub: Derivative_Type;

begin

Result_sub.f := a.f - b.f;

Result.sub.df := a.df - b.df;

end;

global operator * (a,b: Derivative_Type) Result_mul: Derivative_Type;

begin

Result_mul.f := a.f * b.f;

Result_mul.df := a.f * b.df + a.df * b.f;

end;

global operator / (a,b: Derivative_Type) Result_div: Derivative_Type;

begin

Result_div.f := a.f / b.f;

Result_div.df := (a.df - a.f * b.df / b.f) / b.f ;

end;

end. { конец модуля diff_ari }

program Automatic_Differentiation (input, output);

{ Упражнение 19. Дифференциальная арифметика }

use diff_ari;

function f (x: Derivative_Type) : Derivative_Type;

var

three, four : Derivative_Type;

begin

three := 3;

four := 4;

f:= x*((four+x)/(three-x));

end;

var

x, у : Derivative_Type;

h : real;

i : integer;

begin

writein (’Exercise 19: Differentiation Arithmetic’); writein;

x. df : = 1;

h := 0.125;

writeln(’ x ’ , ’ ’,

’ f(x)

’ f”(x) ’);

for i:= 0 to 48 do

begin

x.f := -4 + i * h;

у := f(x);

writein (x.f,’ ’,y.f,’ ’,y.df);

end;

end.

Вывод времени выполнения

Exercise 19: Differentiation Arithmetic

x

• -4.000000000000000E+000
• -3.875000000000000E+000
• -3.750000000000000E+000
• -3.625000000000000E+000
• -3.500000000000000E+000
• -3.375000000000000E+000
• -3.250000000000000E+000
• -3.125000000000000E+000
• -3.000000000000000E+000
• -2.875000000000000E+000
• -2.750000000000000E+000

f(x)

• 0.000000000000000E+000
• -7.045454545454545E-002
• -1.388888888888889E-001
• -2.051886792452830E-001
• -2.692307692307693E-001
• -3.308823529411765E-001
• -3.900000000000000E-001
• -4.464285714285714E-001
• -5.000000000000000E-001
• -5.505319148936170E-001
• -5.978260869565217E-001

f’(x)

• -5.714285714285714E-001
• -5.557024793388429E-001
• -5.390946502057612E-001
• -5.215379138483447E-001
• -5.029585798816567E-001
• -4.832756632064591E-001
• -4.624000000000000E-001
• -4.402332361516035E-001
• -4.166666666666667E-001
• -3.915799004074241E-001
• -3.648393194706995E-001

-2.625000000000000Е+000 -2.500000000000000Е+000 -2.375000000000000Е+000 -2.250000000000000Е+000 -2.125000000000000Е+000 -2.ОООООООООООООООЕ+ООО -1.875000000000000Е+000 -1.750000000000000Е+000 -1.625000000000000Е+000 -1.500000000000000Е+000 -1.375000000000000Е+000 -1.250000000000000Е+000 -1.125000000000000Е+000 -1.ОООООООООООООООЕ+ООО -8.750000000000000Е-001 -7.500000000000000Е-001 -6.250000000000000Е-001 -5.000000000000000Е-001 -3.750000000000000Е-001 -2.500000000000000Е-001 -1.250000000000000Е-001

О.ОООООООООООООООЕ+ООО 1.250000000000000Е-001 2.500000000000000Е-001 3.750000000000000Е-001 5.000000000000000Е-001 6.250000000000000Е-001 7.500000000000000Е-001 8.750000000000000Е-001 1.ОООООООООООООООЕ+ООО 1.125000000000000Е+000 1.250000000000000Е+000 1.375000000000000Е+000 1.500000000000000Е+000 1.625000000000000Е+000 1.750000000000000Е+000 1.875000000000000Е+000 2.ОООООООООООООООЕ+ООО

-6.416666666666666Е-001 -6.818181818181818Е-001 -7.180232558139534Е-001 -7.500000000000000Е-001 -7.774390243902439Е-001 -8.ОООООООООООООООЕ-ОО1 -8.173076923076923Е-001 -8.289473684210525Е-001 -8.344594594594594Е-001 -8.333333333333334Е-001 -8.250000000000000Е-001 -8.088235294117647Е-001 -7.840909090909092Е-001 -7.500000000000000Е-001 -7.056451612903225Е-001 -6.500000000000000Е-001 -5.818965517241379Е-001 -5.000000000000000Е-001 -4.027777777777778Е-001 -2.884615384615384Е-001 -1.550000000000000Е-001

О.ОООООООООООООООЕ+ООО 1.793478260869565Е-001 3.863636363636364Е-001 6.250000000000000Е-001 9.000000000000000Е-001 1.217105263157895Е+000 1.583333333333333Е+000 2.007352941176471Е+000 2.500000000000000Е+000 3.075000000000000Е+000 3.750000000000000Е+000 4.548076923076922Е+000 5.500000000000000Е+000 6.647727272727272Е+000 8.049999999999999Е+000 9.791666666666666Е+000 1.200000000000000Е+001

-3.362962962962963Е-001 -3.057851239669422Е-001 -2.731206057328286Е-001 -2.380952380952381Е-001 -2.004759071980964Е-001 -1.599999999999999Е-001 -1.163708086785009Е-001 -6.925207756232682Е-002 -1.826150474799126Е-002 3.703703703703709Е-002 9.714285714285709Е-002 1.626297577854672Е-001 2.341597796143251Е-001 3.125000000000000Е-001 3.985431841831426Е-001 4.933333333333334Е-001 5.980975029726516Е-001 7.142857142857143Е-001 8.436213991769548Е-001 9.881656804733727Е-001 1.150400000000000Е+000 1.333333333333333E+000 1.540642722117202Е+000 1.776859504132231Е+000 2.047619047619048Е+000 2.360000000000000Е+000 2.722991689750693Е+000 3.148148148148148Е+000 3.650519031141868Е+000 4.250000000000000Е+000 4.973333333333333Е+000 5.857142857142857Е+000 6.952662721893491Е+000 8.333333333333332Е+000 1.010743801652893Е+001 1.244000000000000Е+001 1.559259259259259Е+001 2.000000000000000Е+001

Упражнение 20. Метод Ньютона с автоматическим

дифференцированием

Нуль функции /(х) может быть найден методом Ньютона с начальным приближением Xq

_ /Ы _ n 1 О

^п+1 — Х_{п ?}, / >. ? 71 — 0,1, 2,...

/ ы

Значения функции f и ее производной могут быть вычислены одновременно с помощью соответствующих операций из модуля, представленного в предыдущем упражнении.

Требуется написать программу на языке PASCAL-XSC, реализующую метод Ньютона с применением дифференциальной арифметики. Для проверки используйте функцию

f(x) — е^х — х — 5.

Программа должна считывать начальное приближение хо и производить пять итераций, печатая на каждом шаге значения Xi и f(xi).

Проверьте программу, задав начальные значения Xq = 2.0 и Xq = —5.0. Нули функции равны Xi = 1.9368470722 и х? = —4.99321618865.

Подсказка. Функцию е^и, где U = (и, и') принадлежит типу Derivative_Туре, можно реализовать с помощью следующего соотношения:

_eU _=е(и,и') ₌ (_еи,_и/

Решение

program newt_diff (input, output);

{ Упражнение 20. Метод Ньютона с автоматическим дифференцированием } use diff_ari;

function exp (x: Derivative_Type) : Derivative_Type;

begin

exp.f := exp(x.f);

exp.df:= x.df * exp(x.f);

end;

function f (x: Derivative_Type) : Derivative_Type;

var

five : Derivative_Type;

begin

five := 5;

f := exp(x) - x - five;

end;

var

x, у : Derivative_Type;

i : integer;

begin

writein (’Exercise 20: Newton’’s Method with’);

writein (’ Automatic Differentiation’);

writein;

write (’Enter starting value xO : ’); read (x.f);

x.df := 1;

for i:= 1 to 5 do

begin

у := f(x);

x.f := x.f - y.f/y.df;

writein (’x’,i:l,’ : ’,x.f);

end;

end.

Вывод времени выполнения

Exercise 20: Newton’s Method with

Automatic Differentiation

Enter starting value xO : 2.0

xl : 1.939105856497994E+000

x2 : 1.936850383714592E+000

x3 : 1.936847407225395E+000

x4 : 1.936847407220219E+000

x5 : 1.936847407220219E+000

Exercise 20: Newton’s Method with

Automatic Differentiation

Enter starting value xO : -5.0 xl : -4.993216345093695E+000 x2 : -4.993216188647903E+000 x3 : -4.993216188647903E+000 x4 : -4.993216188647903E+000 x5 : -4.993216188647903E+000

Упражнение 21. Измерение времени

Время суток в диапазоне от 00.00.00 до 23.59.59, с указанием часов, минут и секунд, можно представить как тип записи Clock с соответствующими компонентами. Напишите декларацию операции +, складывающей два значения времени типа Clock и вычитающей, если необходимо, 24 часа, чтобы результат также был представим как значение этого типа. Напишите программу с использованием этих деклараций, которая считывает до maxint значений времени и суммирует их, печатая сумму на каждом шаге. Программа заканчивает работу при вводе значения 0.00.00.

Значение времени вводится как строка формата hh.mm.ss и преобразуется в значение типа Clock с помощью функций языка PASCAL-XSC для работы со строками. При выводе суммарного времени производится обратная операция: значение типа Clock преобразуется в строку символов формата hh.mm.ss и выводится на печать.

Решение

program times (input, output);

{ Упражнение 21. Измерение времени }

type

Clock = record

hours : 0..23;

minutes : 0..59;

seconds : 0..59;

end;

var

a, b : string[8];

time, total : Clock;

i, p : integer;

operator + (a, b: Clock) sum : Clock;

var

help : 0..119;

begin

help := a.seconds + b.seconds;

sum.seconds: = help mod 60;

help := a.minutes + b.minutes + help div 60;

sum.minutes:= help mod 60;

help := a.hours + b.hours + help div 60;

sum.hours := help mod 24;

end;

begin

writein (’Exercise 21: Measurement of Time’);

writein;

total.hours := 0;

total.minutes := 0;

total.seconds := 0;

i: = 0;

repeat

i:= succ (i);

write (’Please enter difference of time: ’); readln;

until (i=maxint) or (time.hours+time.minutes+time.seconds=0); end.

Упражнение 22. Метод итераций

Рассмотрим векторный метод итераций

(*) _ж^(А:+1) =_{с +} Ах^{к А; = 0,1,2,...

где с, G JRⁿ, к = 0,1,2,... и A G JR^n/ri. Предположим, что спектраль

ный радиус А меньше единицы, так что итерации сходятся.

Требуется написать программу на языке PASCAL-XSC, реализующую этот метод, и разработать модуль MatVec, содержащий необходимые типы, операции и процедуры. Модуль должен включать следующие части:

• а) декларацию динамического типа vector как одномерного массива с компонентами типа real;
• б) декларацию динамического типа matrix как двумерного массива с компонентами типа real;
• в) операцию равенства = для сравнения двух векторов а = (а*) и b = = (bi) в соответствии с формулой

ср = bi для всех г;

г) операцию + для сложения двух векторов а = (aj и b = (bi) в соответствии с формулой

с = а + 6, где Ci = а_г + bi для всех i;

д) операцию * для умножения матрицы А = (dij) на вектор х = (xi) в соответствии с формулой

у = А * х, где y-i = ^aij^xj Аая всех i.

з

При этом необходимо использовать тип dot precision, чтобы обеспечить вычисление у_г с единственным округлением;

• е) совмещение процедуры read для ввода вектора;
• ж) совмещение процедуры read для ввода матрицы;
• з) совмещение процедуры write для вывода вектора.

Напишите программу Iteration, использующую модуль MatVec и содержащую следующие части:

1) процедуру Main с формальным параметром п, работающую с типами,

процедурами и операциями модуля MatVec. Процедура должна объявить переменные с, А и х^° необходимые для итераций, как векторы или матрицы с диапазоном индексов и прочитать их зна

чения. Далее Main должна осуществлять итерации (*) пока не выполнится одно из условий = х^ или к — 20. Наконец, она должна напечатать вектор-результат a/^fe+1

2) главную программу, считывающую размерность п и вызывающую процедуру Main.

Решение

module MatVec;

{ Упражнение 22. Модуль с векторно-матричными операциями }

global type

vector = dynamic array [*] of real;

matrix = dynamic array [*,*] of real;

global operator = (a, b: vector) equ: boolean;

{ Предполагаются соответствующие диапазоны индексов у а и b. } var

i : integer;

begin

i:= Ibound(a) - 1;

repeat

i:= i + 1;

until (a[i] <> b[i]) or (i = ubound(a));

equ:= (a[i] = b[i] );

end;

global operator + (a,b: vector) vadd: vector[Ibound(a)..ubound(a)]; { Предполагаются соответствующие диапазоны индексов у а и b. } var

i : integer;

begin

for i:= Ibound(a) to ubound(a) do vadd[i] := a[i] + b[i] ;

end;

global operator * (A: matrix; x: vector)

mvmul: vector[Ibound(x)..ubound(x)];

{ Предполагаются соответствующие диапазоны индексов у А и х. } var

i, j : integer;

d : dotprecision;

begin

for i:= Ibound(A) to ubound(A) do

begin

d: = #(0);

for j: = lbound(A,2) to ubound(A,2) do d:= #(d + a[i,j] * x[j]);

mvmul[i] : = #*(d);

end;

end;

global procedure read (var f: text; var c: vector); var

i : integer;

begin

for i:= Ibound(c) to ubound(c) do read (f, c [i]);

end;

global procedure read (var f: text; var A: matrix); var

i, j : integer;

begin

for i:= Ibound(A) to ubound(A) do

for j := lbound(A,2) to ubound(A,2) do read(f, A[i,j]);

end;

global procedure write (var f: text; c: vector); var

i : integer;

begin

for i:= Ibound(c) to ubound(c) do writein (f, c[i]);

end;

end. { конец модуля MatVec }

program iterate (input, output);

{ Упражнение 22. Метод итераций }

use matvec;

var

n : integer;

procedure main (n: integer);

var

i, j, k : integer;

c, x_k, x_k_plus_l, у : vector[1..n];

A : matrix[1..n,1..n];

begin

writein (’Enter vector c’);

read (c);

writein (’Enter matrix A’);

read (A);

writein (’Enter vector xO’);

read (x_k_plus_l);

{ Итерация }

k:= -1;

repeat

x_k := x_k_plus_l;

k := k + 1;

x_k_plus_l:= c + A * x_k;

until (x_k_plus_l = x_k) or (k = 20);

writein (’Last iterate: ’);

write (x_k_plus_l);

end;

begin { главная программа }

writein (’Exercise 22: Iterative Method x_k+l := c + A x_k’); writein;

write (’Dimension of vectors and matrices? ’);

read (n);

main (n);

end.

Замечание. Модуль MatVec — прототип предопределенного модуля MV_ARI, использующего предопределенные типы rvector и rmatrix. Заметим, что наш модуль не проверяет соответствие диапазонов индексов.

Упражнение 23. След произведения матриц

След п х п матрицы А = (а^) размерности п х п определяется как

п

Trace (А) := ац = ац Н-----Н а_пп,

г=1

т. е. он равен сумме элементов главной диагонали. Требуется написать программу на языке PASCAL-XSC, которая запрашивает размерность п, считывает две п х n-матрицы А и В, вычисляет след произведения матриц С = А х В и печатает его значение.

Используйте модуль MV_ARI, содержащий процедуры и определения операций для динамических типов rvector и rmatrix. Напишите функцию Tracel, вычисляющую след произведения двух матриц с использованием обычных арифметических операций, функцию Trace2, использующую для тех же операций # -выражения с целью достижения максимальной точности, функцию ТгасеЗ, производящую суммирование обычным образом, но применяющую скалярное произведение для вычисления диагональных элементов, и функцию Тгасе4, содержащую # -выражение для суммирования диагональных элементов, полученных тем же способом, как и в функции ТгасеЗ. Сравните результаты, выдаваемые этими четырьмя вариантами функции для различных исходных данных. Проверьте вашу программу на матрицах

Решение

program trace (input, output);

{ Упражнение 23. След произведения матриц }

use mv_ari;

var n: integer;

function tracel (a, b: rmatrix): real; var

i, j : integer;

s : real;

begin

s:= 0;

for i:= lbound(a,l) to ubound(a,l) do

for j:= lbound(a,2) to ubound(a,2) do s:= s + a[i,j] * b[j,i];

tracel:= s; end;

function trace2 (a, b: rmatrix): real; var

i, j : integer;

begin

trace2:= #* ( for i:= lbound(a,l) to ubound(a,l) sum

( for j: = lbound(a,2) to ubound(a,2) sum ( a[i, j]*b[j ,i] ) ) );

end;

function trace3 (a, b: rmatrix): real; var

i : integer;

s : real;

begin

s := 0;

for i:= lbound(a,l) to ubound(a,l) do s:= s + a[i] * rvector(b[*,i]);

trace3:= s;

end;

function trace4 (a, b: rmatrix): real; var

i : integer;

begin

trace4:= #* ( for i:= lb(a,l) to ub(a,l) sum ( a[i] * rvector (b[*,i]) ) ); end;

procedure main (n: integer);

var

a, b : rmatrix[1..n,1..n];

tri, tr2, tr3, tr4 : real;

begin

writein(’Enter matrix A:’);

read (A);

writeln(’Enter matrix B:’) ;

read (B);

trl:= tracel (A,B);

tr2:= trace2 (A,B);

tr3:= trace3 (A,B);

tr4: = trace4 (A,B);

writeln(’Trace of A*B computed conventionally : ’,trl);

writeln(’and with corresponding #-expression : ’,tr2);

writeln(’Trace of A*B computed with scalar product : ’,tr3); writeln(’and with corresponding #-expression : ’,tr4);

end;

begin { программа trace }

writein (’Exercise 23: Trace of a Product Matrix’); writein;

write(’Enter dimension of the matrices: ’);

read (n);

main(n);

end. { конец программы trace}

Вывод времени выполнения

Exercise 23: Trace of a Product Matrix

Enter dimension of the matrices: 4

Enter matrix A:

Trace of A*B computed conventionally and with corresponding #-expression Trace of A*B computed with scalar product and with corresponding #-expression

• -1.600000000000000E+001
• 5.999999999999999E+000
• -9.999999999999999E-016
• 5.999999999999999E+000

Упражнение 24. Калькулятор для полиномов

Требуется написать программу на языке PASCAL-XSC, представляющую собой калькулятор для сложения и умножения полиномов с real-

коэффициентами. Степень п полиномов не превышает 5. Для двух полиномов р и q степени п, заданных в виде

п п

р(х) ^{= и =}

2=0 2=0

сумма s вычисляется по формуле

п

з(я) = р(ж) + q(x) = + bi)x^l,

2=0

а произведение г — по формуле

п п

г(х) = р(х) • q(x) = aibjX^l+P

2=0 j=0

Необходимо написать модуль, содержащий:

• а) определение динамического типа Polynomial как массива с real-элементами;
• б) процедуру для ввода коэффициентов полинома;
• в) операцию + для двух операндов типа Polynomial, возвращающую полином той же степени, что и исходные полиномы;
• г) операцию * для двух операндов типа Polynomial, возвращающую полином соответствующей степени, вычисленный с максимальной точностью;
• д) процедуру для вывода полиномов.

Программа для тестирования этого модуля должна содержать процедуру Main с аргументом п (^5), которая объявляет три полинома (р, q, s) степени п и полином (г) степени 2п и считывает р и q. В зависимости от запроса пользователя процедура должна вычислить и напечатать сумму полиномов s или их произведение г. В теле главной программы нужно лишь запросить у пользователя степень полиномов и вызвать процедуру Main.

Решение

module poly;

{ Упражнение 24. Калькулятор для полиномов }

global type Polynomial = dynamic array [*] of real;

global procedure read (var f: text; var a: Polynomial);

var i: integer;

begin for i:= 0 to ub(a) do read (f, a[i]);

end;

global operator + (a, b: Polynomial) Result_Add: Polynomial[0..ub(a)] ;

var i: integer;

begin

for i:= 0 to ub(a) do

Result_Add[i] := a[i] + b[i];

end;

global operator * (a, b: Polynomial) Result_Mul: Polynomial[0..2*ub(a)]; var i, j, n: integer;

begin

n:= ub(a);

for i:= 0 to n do

Result_Mul[i]:= #* (for j:= 0 to i sum (a[j] * b[i-j]));

for i:= n+1 to 2*n do

Result_Mul[i]:= #* (for j:= i-n to n sum (a[j] * b[i-j]));

end;

global procedure write (var f: text; a: Polynomial);

var i: integer;

begin

write (f, a[0], ’ ’);

for i:= 1 to ub(a) do

begin

writeln(f, ’ + ’);

write(’ a[i], ’ x~’ ,i:l);

end;

writeln(f);

end;

end. { конец модуля poly }

program test_poly (input, output);

use poly;

var n, option : integer;

procedure Main (n : integer; var option : integer);

var

p, q, s : Polynomial[0..n];

r : Polynomial[0..2*n] ;

begin

writein(’Enter the coefficients of p (0 to n):’);

read (p);

writein;

writein(’Enter the coefficients of q (0 to n):’);

read (q);

writein;

repeat

writeln(’Please select:’);

writeln(’ p + q ==> O’);

writeln(’ р * q ==> 1’);

writein(’ New polynomials p,q ==> 2’);

writeln(’ Terminate program ==> 9’);

writein;

write (’Selection ==> ’); read(option);

writein;

if option = 0 then

begin

s:= p+q;

write(’p = ’); writein(p);

write(’q = ’); writeln(q);

write(’p+q = ’); writeln(s);

end

else if option = 1 then

begin

r: = p*q;

write(’p = ’); writein(p);

write(’q = ’); writeln(q);

write(’p*q = ’); writeln(r);

end;

until (option <> 0) and (option <> 1);

writein;

end;

begin { программа test_poly }

writeln(’Exercise 24: Calculator for Polynomials’);

writein;

repeat

repeat

write(’Degree n of the polynomials (>= 0 and <= 5) : ’); read (n);

until (0<=n) and (n<=5);

writein;

Main (n, option);

until (option = 9);

end. { конец программы test_poly }

Вывод времени выполнения

Exercise 24: Calculator for Polynomials

Degree n of the polynomials (>= 0 and <= 5) : 4

Enter the coefficients of p (0 to n): 99 11 22 33 44

Enter the coefficients of q:

0 12 3 4

Please select:

p+q ==> 0

p * q ==> 1

New polynomials p,q ==> 2

Terminate program ==> 9

Selection ==> 0

р = 9.900000000000000Е+001 +

1.100000000000000Е+001 х"1 + 2.200000000000000Е+001 х~2 + 3.300000000000000Е+001 х“3 + 4.400000000000000Е+001 х~4

q = 0.ОООООООООООООООЕ+ООО +

• 1.ОООООООООООООООЕ+ООО х“1 +
• 2.ОООООООООООООООЕ+ООО х~2 +
• 3.000000000000000Е+000 х~3 +
• 4.ОООООООООООООООЕ+ООО х~4

p+q = 9.900000000000000Е+001 +

• 1.200000000000000Е+001 х~1 +
• 2.400000000000000Е+001 х~2 +
• 3.600000000000000Е+001 х~3 +
• 4.800000000000000Е+001 х~4

Please select:

p + q ==> О

р * q ==> 1

New polynomials p,q ==> 2

Terminate program ==> 9

Selection ==> 1

p = 9.900000000000000E+001 +

1.100000000000000E+001 x“l + 2.200000000000000E+001 x“2 + 3.300000000000000E+001 x~3 + 4.400000000000000E+001 x~4

q = 0.000000000000000E+000 +

• 1.000000000000000E+000 x~l +
• 2.000000000000000E+000 x~2 +
• 3.000000000000000E+000 x~3 +
• 4.000000000000000E+000 x~4

p*q = 0.000000000000000E+000 +

9.900000000000000E+001 x"l + 2.090000000000000E+002 x~2 + 3.410000000000000E+002 x~3 + 5.060000000000000E+002 x~4 + 2.200000000000000E+002 x“5 + 2.750000000000000E+002 x~6 + 2.640000000000000E+002 x~7 + 1.760000000000000E+002 x'8

Please select:

p+q ==> 0

p * q ==> 1

New polynomials p,q ==> 2

Terminate program ==> 9

Selection ==> 9

Упражнение 25. Интервальный метод Ньютона

Интервальное включение Х_п нуля функции f(x) с непрерывной и не равной нулю на интервале [а, Ь] производной может быть улучшено при условии f(a) -f(F) <0 с помощью интервального метода Ньютона ([2], [3], [39]):

^{( п)} /'(%„) )

где т(Х) — средняя точка интервала X.

Требуется написать программу на языке PASCAL-XSC, использующую модуль I_ARI, которая вычисляет интервальное включение нуля функции

/(ж) = у/х + (ж + 1) cos х

с помощью описанного выше метода. Программа должна содержать:

• • функцию F, вычисляющую f(X) с использованием интервальной арифметики;
• • функцию DF, вычисляющую производную /^х(ж) с использованием интервальной арифметики;
• • функцию midpoint, вычисляющую среднюю точку т интервала X = = [Ж1,Ж2] с максимальной точностью, применяя #-выражение;
• • главную программу, считывающую начальный интервал X = [а, Ь], проверяющую два условия f(a) ? f(b) <0 и 0 DF(X) и вычисляющую итерации по методу Ньютона. При каждой итерации новый интервал выводится на печать. Процесс завершается, когда X_n+i = Х_п (о конечной сходимости см. [39]).

Подсказка. Используйте [2.0,3.0] в качестве начального интервала. Обратите внимание, что для вычисления /(т(Х)) с помощью интервальной функции F среднюю точку интервала, возвращаемую функцией midpoint, необходимо преобразовать в интервал.

Решение

program i_newton (input, output);

{ Упражнение 25. Интервальный метод Ньютона } use i_ari;

var х, у : interval;

function F (x : interval) : interval;

begin

F:= sqrt(x) + (x+1) * cos(x);

end;

function DF (х : interval) : interval;

begin

DF:= 0.5/sqrt(x) + cos(x) - (x + 1) * sin(x); end;

function midpoint (x : interval) : real;

begin

midpoint:= #* (0.5 * x.inf + 0.5 * x.sup); end;

function criterion_satisfied (x : interval) : boolean; var

a, b: interval;

begin

a:= intval(inf(x));

b:= intval(sup(x));

criterion_satisfied:= (sup(F(a)*F(b)) < 0) and (not (0 in DF(x))); end;

begin

writeln(’Exercise 25: Interval Newton Method’); writein;

write (’Starting interval: ’); read (y); writein;

writein (’Iteration’); writein;

if criterion.satisfied (y) then

repeat

writein (y);

x:= y;

y:= ( midpoint(x) - F ( intval(midpoint(x)) ) / DF(x) ) ** x;

until у = x

else

writein (’Criterion not satisfied!’);

end.

Вывод времени выполнения

Exercise 25: Interval Newton Method

Starting interval: [2,3]

Iteration

[ 2.0E+000,

[ 2.0E+000,

[ 2.05E+000,

[ 2.05903E+000,

[ 2.059045253413E+000,

[ 2.059045253415143E+000,

3.0E+000] 2.3E+000] 2.07E+000] 2.05906E+000] 2.059045253417E+000] 2.059045253415145E+000]

Упражнение 26. Метод Рунге-Кутты

Метод Рунге-Кутты [53] используется для приближенного решения задачи Коши где

и

/ Л(ж,7/1,...,Уп)

ВД = :

fn(x, yi Уп) /

Введем коэффициенты К,:

К_х = h*F(x,Y),

K₂ = h*F(x + |,У + ^-),

K₃ = h*F(x + ^,Y+^'),

K_t = htF(x + h,Y + К₃).

Приближение для решения Y в точке х + h дается формулой

Y(x + А) = У (я) + (Ki + 2F₂ + 2F₃ + F₄)/6.

Требуется написать программу на языке PASCAL-XSC, использующую / ¹

модуль MV_ARI. Начиная с У (0) — I 0 I, значения У вычисляются в ¹ /

точках Xj = i * h, i = 1,..., 10, где h = 0.125. В качестве примера следует использовать функцию

/ У1 - У2

F(x, У) = е^х • У₃

Щ - Y₂)/e^x

Вывод должен быть представлен в форме таблицы. Определите векторную функцию F(rr, У). Вычисляйте значения К±, К%, К%, и У(а?г) в цикле с помощью предопределенных операций модуля MV_ARI.

Решение

program Runge_Kutta (input, output);

{ Упражнение 26. Метод Рунге-Кутты } use mv_ari;

const

n = 3;

var

h, х : real;

Y : rvector[1..n];

i : integer;

function F (x : real; Y : rvector) : rvector[1..n];

var i: integer;

begin

F[l] := Y[l] - Y[2] ;

F[2]:= exp(x) * Y[3] ;

F[3] := (Y[1J - Y[2J) / exp(x);

end;

function 0ne_Step (x, h : real; var Y : rvector) : rvector[1..n];

{ Функция реализует один шаг метода Рунге-Кутты } var

kl, k2, k3, к4 : rvector[1..n];

begin

kl := h * F (x , Y);

k2 := h * F (x + h/2, Y + kl/2);

k3 := h * F (x + h/2, Y + k2/2);

k4 := h * F (x + h , Y + k3);

One.Step := Y + (kl + 2 * k2 + 2 * k3 + k4) /6;

end;

begin

writein(’Exercise 26: Runge-Kutta Method’);

writein;

x: = 0; Y[l]:= 1; Y[2] := 0; Y[3] := 1; h:= 0.125;

writein (’ x Y’);

write (’--------------------------------------’ ) ;

writein (’-------------------------------------’) ;

writein (xi:7:4,’ ’,Y[1],’ ’,Y[2],’ ’,Y[3]);

for i:=l to 10 do

begin

x := i*h;

Y := 0ne_Step (x, h, Y);

writein (x:7:4,’ ’,Y[1],’ ’,Y[2],’ ’,Y[3]); end;

end.

Вывод времени выполнения

Exercise 26: Runge-Kutta Method

• 0.0000
• 0.1250
• 0.2500
• 0.3750
• 0.5000
• 0.6250
• 0.7500
• 0.8750
• 1.000000000000000E+000
• 1.123177059359435E+000
• 1.239209386091870E+000
• 1.341958893792722E+000
• 1.424014481447932E+000
• 1.476592898728182E+000
• 1.489460043511421E+000
• 1.450881281820536E+000
• 0.000000000000000E+000
• 1.589550140041404E-001
• 3.550710525572459E-001
• 5.919581434349622E-001
• 8.728079152996371E-001
• 1.200161743578859E+000
• 1.575636069976619E+000
• 1.999602458523678E+000
• 1.000000000000000E+000
• 1.102222238011605E+000
• 1.187244664965584E+000
• 1.253740540716452E+000
• 1.300672225680391E+000
• 1.327307372755333E+000
• 1.333230355256656E+000
• 1.318348752540877E+000

• 1.0000 1.347610792483193Е+000 2.470820861695647Е+000 1.282894792112784Е+000
• 1.1250 1.164931397828429Е+000 2.986025793442226Е+000 1.227421725713755Е+000
• 1.2500 8.867578092820163Е-001 3.539466687473293Е+000 1.152795195942419Е+000

Замечание. На примере последних двух упражнений видно, что принцип совмещения операций в PASCAL-XSC существенно упрощает отображение численных алгоритмов в текст программы. Как правило, математические формулы оказывается возможным использовать непосредственно как операторы в программе.

Упражнение 27. Рациональная арифметика

Требуется написать модуль на языке PASCAL-XSC, реализующий рациональную арифметику [27]. Рациональное число p = n/d должно быть представлено как запись с компонентами типа integer: numerator (числитель) и denominator (знаменатель, который должен быть больше нуля). Модуль должен содержать следующие глобальные декларации:

• а) тип Rational;
• б) операции +, *, /, возвращающие результат типа Rational, причем

числитель и знаменатель должны быть взаимно простыми;

в) процедуры для ввода и вывода рациональных чисел в форме

integer/integer.

Необходимо написать функции для вычисления наибольшего общего делителя и для сокращения дроби, объявленные локально и доступные только в пределах модуля.

Программа, тестирующая работу модуля, должна проверить работу каждой операции и вычислить значение выражения

(а + 5) * (b - с)/(с + d),

где а = 3/4, 6 = 2/7, с — 4/5 и с/= 7/9.

Подсказка. Функция, сокращающая дробь, должна использовать операцию целочисленного деления (div) числителя и знаменателя на наибольший общий делитель. Для нахождения наибольшего общего делителя можно применить следующий алгоритм:

а, b > 0, zq := а, tiq := b, i := О,

Пусть / 1 при i = 0.1, 2,...

[ di₊i := rii mod di J

пока не выполнится условие <Д+1 — 0.

Тогда Пг+i (или di) — наибольший общий делитель а и Ь.

Обратите внимание, что наибольший общий делитель нуля и не равного нулю х всегда равен х.

Решение

module rational;

{ Упражнение 27. Рациональная арифметика }

global type

positive = 1..maxint;

rational = record

numerator : integer;

denominator : positive;

end;

function gcd (a, b : integer) : positive;

var

n, d, r : integer;

begin

if a = 0 then gcd:= b

else if b = 0 then

gcd:= a

else

begin

d:= a;

r:= b;

repeat

n:= d;

d: = r;

r:= n mod d;

until r = 0;

gcd:= abs(d);

end;

end;

function reduce (a: rational) : rational;

var

g : positive;

begin

g:= gcd (abs(a.numerator),a.denominator);

if (g = 0) or (g = 1) then reduce := a

else

begin

reduce.numerator := a.numerator div g;

reduce.denominators a.denominator div g;

end;

end;

global operator + (a,b : rational) respl : rational;

var

s: rational;

begin

s.numerator := a.numerator*b.denominator + b.numerator*a.denominator; s. denominator: = a. denominator^. denominator;

respl:= reduce (s);

end;

global operator - (a,b : rational) resmi : rational;

var s: rational;

begin

s.numerator := a.numerator*b.denominator - b.numerator*a.denominator; s . denominator: = a. denominator^. denominator;

resmi:= reduce (s);

end;

global operator * (a,b : rational) resmu : rational;

var s: rational;

begin

s.numerator := a.numerator*b.numerator;

s.denominator:= a.denominator*b.denominator;

resmu:= reduce (s);

end;

global operator / (a,b : rational) resdi : rational; var help : integer;

s : rational;

begin

s.numerator:= a.numerator*b.denominator;

help := a.denominator*^numerator;

if help > 0 then

s. denominators help

else if help < 0 then begin

s.numerator := -s.numerator;

s.denominator:= -help; end

else { искусственный вызов ошибки делением на ноль } helps help div help;

resdis reduce (s) ;

end;

global procedure read (var f: text; var r: rational); var

s, sn, sd: string;

i, 1 : integer;

begin

if eoln (f) then readln (f);

read (f,s);

is pos (’/’,s);

Is length (s);

sns substring (s,l,i-l);

sds substring (s,i+l,l-i);

r.numerators ival (sn);

Is ival (sd);

if 1 > 0 then r.denominator:= 1

else if 1 < 0 then begin

r.numerator s - r.numerator;

r.denominator s - 1;

end

else { искусственный вызов ошибки делением на ноль } 1:= 1 div 1;

г:= reduce (г);

end;

global procedure write (var f: text; a: rational);

begin

write (f, a.numerator:1, ’/’, a.denominator:1);

end;

end. { конец модуля rational }

program test_ratio (input, output);

{ Упражнение 27. Рациональная арифметика (тестовая программа) } use rational;

var

a,b,c,d : rational;

begin

writeln(’Exercise 27: Rational Arithmetic - Test Program’); writein;

writein (d);

writein;

writein (’a+b = ’, a+b);

writein (’b-c = ’, b-c);

writein (’c+d = ’, c+d);

writein (’(a+b)*(b-c)/(c+d) = ’, (a+b)*(b-c)/(c+d)); end.

Вывод времени выполнения

Exercise 27: Rational Arithmetic

a = 3/4

b = 2/7

c = 4/5

d = 7/9

a+b = 29/28

b-c = -18/35

c+d = 71/45

(a+b)*(b-c)/(c+d) = -2349/6958

Упражнение 28. Вычисление полиномов

Требуется написать программу на языке PASCAL-XSC для вычисления значения полинома

p(t) — d_ntⁿ + • • • + dpi + +) с максимальной точностью, используя модуль LSS из библиотеки численных методов языка PASCAL-XSC, предназначенный для верифицированного решения системы линейных уравнений. Схему Горнера

p(t) = (... (а_п • i + a_n_i) • t + а_п_₂) • • •) • t + nJ • t + a_Q для вычисления значения полинома можно реализовать через решение системы линейных уравнений

• 2-‘о — d_n
• — txg + d_n—i
• 2-71—1 — tXn—2 + Я1

= tx_n — i 4- <2-0,

введя п +1 переменных xq, a?i,..., x_n-i, х_п. Значение полинома р в точке t равно х_п, т. е. x_n—p(t).

Таким образом, необходимо решить систему линейных уравнений

/ ¹ 0

Хо

Х1

( dn

dn—1

di

^ао /

• -t 1
• -t 1

о -t 1 у или

Ах = Ь, где

{1 при i = j 'I

• -t при i = j + 1 > , i, j = 0,..., n
• 0 в остальных случаях J

b = (bi bi = d_n-i, i = 0,...,n.

Программа на языке PASCAL-XSC должна содержать: а) определение динамического типа polynomial (с компонентами типа real);

• б) процедуру read для ввода коэффициентов полинома;
• в) функцию Horner для вычисления значения полинома по схеме Горнера;
• г) процедуру set_A_b, порождающую матрицу А и вектор b на основе полинома р и числа t типа real;
• д) процедуру main с формальным параметром п, которая:
  • - объявляет переменную р типа polynomial, вектор b типа rvector, интервальный вектор X типа ivector и квадратную матрицу А типа rmatrix с диапазоном индексов 0,..., п;
  • - считывает коэффициенты полинома ао,...,а_п при помощи процедуры read из пункта (б);
  • - вычисляет матрицу А и вектор b при помощи процедуры из пункта (г);

вычисляет включение X решения системы Ах = b с максимальной точностью при помощи процедуры Iss;

• - и наконец, если процедура Iss завершилась успешно, печатает нижнюю и верхнюю границы интервального включения Х_п значения полинома х_п = p(t) и, для сравнения, значение, полученное по схеме Горнера (пункт (в));
• е) главную программу, запрашивающую у пользователя степень полинома и вызывающую процедуру main.

Подсказка. Необходимо использовать модуль LSS из библиотеки численных методов языка PASCAL-XSC. Этот модуль содержит процедуру Iss, вычисляющую верифицированный включающий вектор X для решения х уравнения Ах = Ъ, исходя из матрицы А и правой части Ь. Процедура Iss объявлена следующим образом:

procedure Iss ( var A: rmatrix; var b: rvector;

var X: ivector; var encode: integer );

где

encode = 0 : успешное завершение;

encode = 1 : система слишком плохо обусловлена;

encode = 2 : возможно, матрица вырожденная.

Проверьте вашу программу на следующих примерах:

Пример 2:

Решение

program Polynomial-Evaluation (input, output);

{ Упражнение 28. Вычисление полиномов }

use i_ari, mv_ari, Iss;

type polynomial = dynamic array [*] of real;

procedure read (var f: text; var p: polynomial);

var

i: integer;

begin

for i:= 0 to ub(p) do

begin

write (’Coeff. ’,i:2,’: ’);

read (f, p [i]);

end;

end;

function Horner (p : polynomial; t: real) : real; var

h: real;

i: integer;

begin

h:= 0;

for i:= ub(p) downto 0 do

h: = p[i] + t * h;

horner:= h;

end;

procedure set_A_b (p : polynomial; t : real;

var A: rmatrix; var b: rvector);

var

i, j, ub_p: integer;

begin

А:= null (А);

А[0,0]:= 1;

for i:= 1 to ub(A) do

begin

A[i,i-1]: = -t; { sub diagonal := -t }

A[i,i] := 1; { diagonal := 1 }

end;

ub_p:= ub(p);

for i:= 0 to ub(b) do b[i] := p[ub_p-i];

end;

procedure main (n: integer);

var

p: polynomial[0..n];

b: rvector[0..n];

X: ivector[0..n];

A: rmatrix[0..n,0..n];

t: real;

error: integer;

begin

writein (’Enter a polynomial’);

read (p);

write (’Enter the point of evaluation t = ’); read(t);

writein;

set_A_b (p,t,A,b);

Iss (A,b,X,error);

if error=0 then

begin

writein (’Horner scheme : ’, horner (p,t));

writein (’Inclusion : ’, X[n]);

end

else

writein (’Error ’,error:1,’ ocurred’);

end;

var n: integer;

begin

writeln(’Exercise 28: Evaluation of Polynomials’);

writein;

write (’Degree of polynomial: ’); read (n);

main (n);

end.

Вывод времени выполнения

Пример 1

Degree of polynomial: 3

Enter polynomial

Coeff. 0 = 1536796802

Coeff. 1 = -1086679440

Coeff. 2 = -768398401

Coeff. 3 = 543339720

Enter the point of evaluation t = 1.4142135

Horner scheme : 5.960464477539062E-006

Inclusion : [ 5.978758733249328E-006, 5.978758733249330E-006]

Пример 2

Degree of polynomial: 3

Enter polynomial

Coeff. 0 = 191971912515

Coeff. 1 = -135744641136

Coeff. 2 = -95985956257

Coeff. 3 = 67872320568

Enter the point of evaluation t = 1.41421353154

Horner scheme : 1.000183105468750E+000

Inclusion : [ 1.000182503810985E+000, 1.000182503810986E+000]

Замечание. Данное упражнение демонстрирует, как подпрограмму для верифицированного решения системы линейных уравнений можно использовать для вычисления полинома с максимальной точностью. В то же время видно, что широко применяемая схема Горнера может давать неточные результаты.

Процедура Iss используется здесь для простоты. Читатель в качестве более сложного упражнения может разработать более эффективный алгоритм, использующий особенности структуры матрицы А (см. [9]).

Приложение А

Синтаксические диаграммы

В дополнение к синтаксическому описанию языка PASCAL-XSC (гл. 2), данному в упрощенной форме Бэкуса-Наура, здесь мы приводим его полное описание. Для этой цели используется особая разновидность синтаксических диаграмм, применявшаяся также в [7], [8] и [17]. Следующие правила определяют построение диаграмм:

• • каждая диаграмма помечается числом, за которым следует специальный идентификатор (последовательность прописных букв), который называется синтаксической переменной. Синтаксические переменные используются для отсылки к представленным элементам языка;
• • диаграммы состоят из синтаксических переменных, терминальных символов (выделенных полужирным шрифтом и записанных строчными буквами зарезервированных слов, заключенных в кружки отдельных символов или заключенных в овалы последовательностей символов), а также сплошных или пунктирных линий;
• • в диаграммах синтаксические переменные могут иметь семантический префикс. Например, переменная ИДЕНТИФИКАТОР (ИД) может употребляться с префиксом КОМП, обозначая особую разновидность идентификатора, а именно идентификатор компоненты. Тем не менее, определение переменной КОМП ИД следует искать на диаграмме ИДЕНТИФИКАТОР.

Кроме того, такие семантические атрибуты могут быть выделены курсивом и располагаться рядом с переменной или снизу от нее. Если приведено несколько атрибутов, запятая между ними понимается как «или». Используются следующие сокращения.

Для облегчения работы с диаграммами список всех синтаксических переменных (идентификаторов) приведен в алфавитном порядке в приложении Б, разд. 1.

Синтаксические диаграммы используются в соответствии со следующими правилами:

• • прохождение диаграммы начинается с верхнего левого угла и заканчивается в правом нижнем;
• • сплошные линии проходятся слева направо или сверху вниз, пунктирные — справа налево или снизу вверх;
• • если при прохождении диаграммы встречается синтаксическая переменная, необходимо пройти диаграмму, на которой определяется эта переменная, после чего вернуться к исходной диаграмме.

Р1 ЕДИНИЦА КОМПИЛЯЦИИ

предложение use

Р2 ДЕКЛАРАЦИИ И ТЕЛО ПРОГРАММЫ (ДТП)

• -------ОБЛАСТЬ ДЕКЛАРАЦИЙ
• ------begin--1- ОПЕРАТОР----end

РЗ ДЕКЛАРАЦИИ И ТЕЛО МОДУЛЯ (ДТМ)

Р4 ДЕКЛАРАЦИЯ МОДУЛЯ

Р6 ОПРЕДЕЛЕНИЕ КОНСТАНТЫ

Р7 КОНСТАНТА (КОНСТ)

У (указатель)

Р8 ОПРЕДЕЛЕНИЕ ТИПА

Список предопределенных идентификаторов

типов языка PASCAL-XSC:

Р9 ОПРЕДЕЛЕНИЕ ТИПА В МОДУЛЕ

РЮ

ТИП

---------ид-

типа

---ид---

константы ПТ

-ид-

типа

Л, С, ПТ

{ string }

---КОНСТ Ц максимтхьная длина

— packed

array

ТИП Ц нижняя граница 1

of

char---

— packed —

array

— ТИП — Ц, А, С, ПТ

of----ТИП--

компонент

— record

СПИСОК ПОЛЕЙ

end---

-----set

of

• — ТИП — Ц, А, С, ПТ
• -----file-----------of
• -ТИП-не ФСТ

ПТ

У

ц

диапазон

Л, С, ПТ

СТР

СТР (статическая), также М

М, также ФСТ, если компоненты — типа ФСТ

ЗАП, также ФСТ, если СП содержит тип ФСТ

МН

Ф, также ФСТ

Р11 СПИСОК ПОЛЕЙ (СП)

Р12 ДЕКЛАРАЦИЯ ПЕРЕМЕННОЙ

Р14 ЗАГОЛОВОК ПРОЦЕДУРЫ/ФУНКЦИИ (ЗП/Ф)

_г procedure----ИД----СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ---------

процедуры

- function----ИД----СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ--О— ТР

функции

Р15 ОПРЕДЕЛЕНИЕ ПРИОРИТЕТА

priority

Р16 ЗАГОЛОВОК ОПЕРАЦИИ

— operator

Р17 СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ УНАРНОЙ ОПЕРАЦИИ (СФП УО)

var----

— ИД — переменной

СТ

Р18 СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ БИНАРНОЙ ОПЕРАЦИИ (СФП БО)

var -]

— ид —

переменной

— ИД — переменной

СТ---

--ИД —

переменной

СТ

var -|

— ИД — переменной

СТ

Р19 СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ ОПЕРАЦИИ ПРИСВАИВАНИЯ (СФП ОП)

var----ИД---

переменной

СТ

var -1

— ИД-

переменной

СТ

Р20 ТИП РЕЗУЛЬТАТА (ТР)

-----ИД ТИПА-----

При использовании в Р14 внутри Р22 допустим также ИД динамического типа

.........Q.........

выр---Q---выр

Ц Ц

• ---ИД ДИН. ТИПА-------Q)
• ( string )?

Р21 ТЕЛО

ОБЛАСТЬ ДЕКЛАРАЦИЙ

begin--— ОПЕР-----end---

forward

external

СТРОКОВАЯ КОНСТАНТА

Р23 СПЕЦИФИКАЦИЯ ТИПА (СТ)

— ИД ТИПА —

ИД ДИН. ТИПА

—( String )—

Р24 ОПЕРАТОР (ОПЕР)

метка

ПЕРЕМЕННАЯ

- РЕЗУЛЬТАТ

ВЫР

оператор присваивания

- begin -I— ОПЕР

end

составной оператор

• - with - ПЕРЕМЕННАЯ
• - while

L- РЕЗУЛЬТАТ

ЗАП

ВЫР —

do

ОПЕР

оператор with

do

ОПЕР

- repeat -I— ОПЕР----until

ВЫР Л

операторы 'цикла

— for----ИД---

переменной

ВНР

ВНР — do - ОПЕР -

— if

ВЫР Л

then — ОПЕР

— else — ОПЕР

условный оператор

case - ВЫР - of ВЫБОР

ОПЕР

Ц, Л, С, ПТ

end

оператор case

goto

ПОСЛЕДОВАТЕЛЬНОСТЬ ЦИФР - оператор метка

---ИД ПРОЦЕДУРЫ---СПИСОК ФАКТИЧЕСКИХ ПАРАМЕТРОВ

goto вызов процедуры

ОПЕРАТОР ВВОДА-ВЫВОДА

ВЫЗОВ СТАНДАРТНОЙ ПРОЦЕДУРЫ

Р25 РЕЗУЛЬТАТ

Предопределенные идентификаторы компонент PASCAL—XSC: re, im, inf, sup

Р26 ВЫЗОВ СТАНДАРТНОЙ ПРОЦЕДУРЫ

Р27 ОПЕРАТОР ВВОДА-ВЫВОДА (ОВВ)

Р28 ВЫРАЖЕНИЕ (ВЫР)

Р29 ВЫСОКОТОЧНОЕ ВЫРАЖЕНИЕ

ТОЧНОЕ ВЫРАЖЕНИЕ

РЗО ТОЧНОЕ ВЫРАЖЕНИЕ (ТВ)

Все слагаемые должны иметь одну и ту же структуру (скаляр, вектор или матрица) и одинаковую размерность.

Явные высокоточные выражения недопустимы в Ц ВЫР оператора for.

Р31 СОМНОЖИТЕЛЬ

ОПЕРАНД

Р32 ОПЕРАНД

КОНСТАНТА Ц,В

----ПЕРЕМЕННАЯ----

стандартного арифм. типа

-----ИД ФУНКЦИИ------ Допустимы только функции compl, re, im, conj, intval, inf, sup, id, transp и herm из арифметических модулей и функции преобразования типа rvector, cvector, ivector, civector, matrix, cmatrix, imatrix, cimatrix (см. разд. 2.4.4).

Р34 УНАРНАЯ ОПЕРАЦИЯ (УО) приоритет 3

ИД УО

-®-

В стандартном Паскале — приоритет 1

— not —

Р36 ПЕРЕМЕННАЯ (ПЕР)

Предопределенные идентификаторы компонент языка PASCAL—XSC: re, im, inf, sup

Р37

Р37 ВЫЗОВ СТАНДАРТНОЙ ФУНКЦИИ (продолжение)

ВЫР В

— ВЫР —

ц, в, дот

ВЫР В

ПЕРЕМЕННАЯ — Ф, ГФ

ВЫР Ц

• -( 1ос )—© ПЕРЕМЕННАЯ--©
• —( Ibound )—
• —(abound

ПЕРЕМЕННАЯ М

ВЫР СТР

—( rval )—(7)"

ВЫР СТР

• -f length 'I—(Т)-------ВЫР-------
• -(maxlength)—©--ПЕРЕМЕННАЯ

формат

Р37 ВЫЗОВ СТАНДАРТНОЙ ФУНКЦИИ (продолжение; предполагается использование арифметических модулей)

---ВНР---

Ц, В, ВИ, вв, ив, вм, им

Ц, В, ВИ, вв, ив, вм, им

—fcompl

• —( intval )--QQ
• ---ВНР--- к, ки, кв, кив, КМ, КИМ
• ---ВНР--- ц, в, к, вв, кв, вм, км
• ---ВЫР--- ц, в, к, вв, кв, вм, км

• -( null )--(7)
• ----ВЫР----

ВИ, ки, ив, кив, ИМ, КИМ

• -----ВЫР----- ц, вв, кв, ив, кив, ВМ, КМ, ИМ, КИМ
• -----ВЫР-----

Ц, ВМ, КМ, ИМ, КИМ

ВЫР ц

-----ВЫР------

Ц, ВМ, КМ, ИМ, КИМ

Ц, ВМ, КМ, ИМ, КИМ

• 7 blow )--(jQ
• ----ВЫР----

ВМ, КМ, ИМ, КИМ

----ВЫР----

ВИ, ки, ив, кив, ИМ, КИМ

ВЫР в

Р38 ИДЕНТИФИКАТОР (ИД)

БУКВА

ЦИФРА

БУКВА

Р39 ПОСЛЕДОВАТЕЛЬНОСТЬ ЦИФР (ПЦ)

ЦИФРА

Р40 ПОСЛЕДОВАТЕЛЬНОСТЬ ШЕСТНАДЦАТЕРИЧНЫХ ЦИФР (ПШЦ)

ШЕСТНАДЦАТЕРИЧНАЯ ЦИФРА

Р41 СИМВОЛ

• -------------------БУКВА ?
• ----------ЦИФРА

набор дополнительных символов зависит от реализации

Р42

БУКВА

1 ⁰ I

Р43

ЦИФРА

• 1—®—
• --Q--
• 1-----®-----1---------

Р44

ШЕСТНАДЦАТЕРИЧНАЯ ЦИФРА

1 ⁰ I

---ЦИФРА

Приложение Б

Справочный раздел

1. Синтаксические диаграммы

Номер Идентификатор диаграммы (синтаксическая переменная) Стр.

РЗЗ БИНАРНАЯ ОПЕРАЦИЯ (БО) .................... 272

Р42 БУКВА ............................... 278

Р13 ВЫБОР ............................... 263

Р26 ВЫЗОВ СТАНДАРТНОЙ ПРОЦЕДУРЫ ............... 268

Р37 ВЫЗОВ СТАНДАРТНОЙ ФУНКЦИИ ................ 268

Р28 ВЫРАЖЕНИЕ (ВЫР) ........................ 270

Р29 ВЫСОКОТОЧНОЕ ВЫРАЖЕНИЕ .................. 271

РЗ ДЕКЛАРАЦИИ И ТЕЛО МОДУЛЯ (ДТМ) .............. 258

Р2 ДЕКЛАРАЦИИ И ТЕЛО ПРОГРАММЫ (ДТП)............ 258

Р4 ДЕКЛАРАЦИЯ МОДУЛЯ....................... 258

Р12 ДЕКЛАРАЦИЯ ПЕРЕМЕННОЙ.................... 263

Р1 ЕДИНИЦА КОМПИЛЯЦИИ ..................... 257

Р16 ЗАГОЛОВОК ОПЕРАЦИИ ...................... 264

Р14 ЗАГОЛОВОК ПРОЦЕДУРЫ/ФУНКЦИИ (ЗП/Ф) ........... 264

Р38 ИДЕНТИФИКАТОР (ИД) ...................... 277

Р7 КОНСТАНТА (КОНСТ) ....................... 260

Р5 ОБЛАСТЬ ДЕКЛАРАЦИЙ ...................... 259

Р32 ОПЕРАНД .............................. 272

Р24 ОПЕРАТОР (ОПЕР) ......................... 267

Р27 ОПЕРАТОР ВВОДА-ВЫВОДА (ОВВ) ................. 269

Р6 ОПРЕДЕЛЕНИЕ КОНСТАНТЫ.................... 259

Р15 ОПРЕДЕЛЕНИЕ ПРИОРИТЕТА ................... 264

Р8 ОПРЕДЕЛЕНИЕ ТИПА ....................... 261

Р9 ОПРЕДЕЛЕНИЕ ТИПА В МОДУЛЕ ................. 261

Р36 ПЕРЕМЕННАЯ (ПЕР) ........................ 274

Р39 ПОСЛЕДОВАТЕЛЬНОСТЬ ЦИФР (ПЦ) ............... 278

Номер Идентификатор диаграммы (синтаксическая переменная)

Стр.

Р40 ПОСЛЕДОВАТЕЛЬНОСТЬ

ШЕСТНАДЦАТЕРИЧНЫХ ЦИФР (ПШЦ) .............. 278

Р25 РЕЗУЛЬТАТ ............................. 267

Р41 СИМВОЛ .............................. 278

Р31 СОМНОЖИТЕЛЬ .......................... 272

Р23 СПЕЦИФИКАЦИЯ ТИПА (СТ) ................... 266

Р11 СПИСОК ПОЛЕЙ (СП) ....................... 262

Р35 СПИСОК ФАКТИЧЕСКИХ ПАРАМЕТРОВ ............. 274

Р22 СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ .............. 266

Р18 СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ

БИНАРНОЙ ОПЕРАЦИИ (СФП БО) ................ 265

Р19 СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ

ОПЕРАЦИИ ПРИСВАИВАНИЯ (СФП ОП) ............. 265

Р17 СПИСОК ФОРМАЛЬНЫХ ПАРАМЕТРОВ

УНАРНОЙ ОПЕРАЦИИ (СФП УО) ................. 265

Р21 ТЕЛО ................................ 266

Р10 ТИП................................. 261

Р20 ТИП РЕЗУЛЬТАТА (ТР) ....................... 266

РЗО ТОЧНОЕ ВЫРАЖЕНИЕ (ТВ) .................... 271

Р34 УНАРНАЯ ОПЕРАЦИЯ (УО)..................... 273

Р43 ЦИФРА ............................... 279

Р44 ШЕСТНАДЦАТЕРИЧНАЯ ЦИФРА .................. 279

2. Зарезервированные слова

and array

begin

case const

div do downto dynamic

else end external

file for forward function

global goto

if in

label

mod module

nil not

of operator or packed priority procedure program record repeat set sum

then to type

until use

var

while with

3. Предопределенные идентификаторы

ub ubound

vnull

Процедуры

dispose

get

mark

new

page put

read readln release reset rewrite

write writein

4. Операции

В этом разделе перечислены все предопределенные операции как ядра языка, так и арифметических модулей.

4.1 Основные операции

4.2 Арифметические операции

^х) Операции в этой строке относятся к унарным (т.е. у них нет левого операнда).

• 2) °е{+,-*,/}•
• 3) о G {+,—,*}, где * обозначает скалярное или матричное произведение.
• 4) * обозначает скалярное или матричное произведение.

+ * : интервальная оболочка (минимальный интервал, включающий оба операнда).

** : пересечение интервалов.

4.3 Операции отношения для арифметических типов

^х) Символы <= и < обозначают отношения подмножества слева,

>= и > — отношения подмножества справа.

: проверка на непересечение.

in : проверка принадлежности точки интервалу

или включения интервала интервалом.

4.4 Операции присваивания

Нижеприведенная таблица содержит перечисление всех возможных комбинаций в операторе присваивания, возникающих при совмещении операций присваивания в арифметических модулях.

5. Предопределенные функции

Этот раздел содержит отсортированный по алфавиту список предопределенных функций с их декларациями (интерфейсом) и кратким описанием назначения. Для функций, которые определяются или совмещаются в арифметических модулях, приводится имя соответствующего модуля. Общие математические функции собраны в дополнительной таблице в конце раздела. Информацию об областях определения и множествах значений функций для конкретной версии компилятора можно найти в соответствующем руководстве пользователя.

См. таблицу

на

стр. 300

arccos

См. таблицу

arccot

См. таблицу

на

на

стр. 300

стр. 300

См. таблицу

на

стр. 300

См. таблицу

на

стр. 300

arcsin

См. таблицу

на

стр. 300

См. таблицу на стр. 300

arctan2 J

См. таблицу на стр. 300

arg Л

function arg (с: complex) : real;

Назначение: возвращает аргумент (угловую компоненту) комплексного числа с, представленного в тригонометрической форме.

Определена/переопределена в C_ARI.

function arg (с: cinterval) : interval;

Назначение: возвращает интервал-аргумент (угловую компоненту) комплексного интервала с, представленного в тригонометрической форме.

Определена/переопределена в CI_ARI.

arsinh

См. таблицу на стр. 300

artanh J

См. таблицу на стр. 300

blow )

function blow (х: Typel; eps: real) : Typel;

Typel: interval, cinterval, ivector, civector, imatrix, cimatrix.

Назначение: возвращает эпсилон-расширение интервального аргумента х (для каждой компоненты в случае составных типов). Для х типа interval функция blow вычисляется так:

у := (1 + eps) * х — eps * х;

blow := intval ( pred(inf(y)) , succ(sup(y)) );

Определена/переопределена в I_ARI, CI_ARI, MVI_ARI, MVCI_ARI.

chr

function chr (i: integer) : char;

Назначение: возвращает символ с порядковым номером 1. Если такого значения не существует, фиксируется ошибка.

comp

function comp (m: real; e: integer) : real;

Назначение: объединяет мантиссу m и порядок е в число с плавающей точкой т • Ъ^е. Если значения Ь, е или т выходят за границы, определенные реализацией, фиксируется ошибка.

conj

function conj (с: Typel) : Typel;

Typel: complex, cinterval, cvector, civector, cmatrix, cimatrix.

Назначение: возвращает сопряженное число (в случае векторных и матричных аргументов — для каждой компоненты).

Определена/переопределена в C_ARI, CI_ARI, MVC_ARI, MVCI-ARI.

cos )

См. таблицу на стр. 300 cosh )

См. таблицу на стр. 300

cot J

См. таблицу на стр. 300 coth J

См. таблицу на стр. 300 diam )

function diam (x: Typel) : ResType;

Typel: interval, cinterval, ivector, civector, imatrix, cimatrix.

ResType: real, rvector, rmatrix в зависимости от структуры

типа Typel.

Назначение: возвращает диаметр интервала х (в случае составных типов — для каждой компоненты).

Определена/переопределена в I_ARI, CI_ARI, MVI_ARI, MVCI_ARI.

function eof (var f: Typel) : boolean;

Typel: text, file of ...

Назначение: возвращает false, если текущая компонента файловой переменной f определена, в обратном случае — true. Если не определена сама файловая переменная f, фиксируется ошибка.

function eof : boolean;

Назначение: соответствует eof(input).

eoln )

function eoln (var f: text) : boolean;

Назначение: возвращает true, если текущая компонента файловой переменной f содержит символ конца строки, в обратном случае — false. Если не определена сама файловая переменная f, фиксируется ошибка.

function eoln : boolean;

Назначение: соответствует eoln(input).

ёхр Л

См. таблицу на стр. 300

ехр2

См. таблицу на стр. 300

ехр10J

См. таблицу на стр. 300

expo J

function expo (х: real) : integer;

Назначение: возвращает порядок числа х, соответствующий нормализованной мантиссе при данном основании.

herm

function herm (x: Typel) : Typel;

Typel: cmatrix, cimatrix.

Назначение: возвращает эрмитову матрицу.

Определена/переопределена в MVC_ARI_r MVCI_ARI.

function id (x: Typel) : rmatrix[lb(x)..ub(x),lb(x,2)..ub(x,2)];

Typel: rmatrix, cmatrix, imatrix, cimatrix.

Назначение: возвращает единичную матрицу той же размерности, что и матрица х.

Определена/переопределена в MV_ARI, MVC_ARI, MVI_ARI, MVCI_ARI.

function id (x, y: Typel) : rmatrix[lb(x)..ub(x),lb(y,2)..ub(y,2)];

Typel: rmatrix, cmatrix, imatrix, cimatrix.

Назначение: возвращает единичную матрицу той же размерности, что и произведение матриц х • у.

Определена/переопределена в MV_ARI, MVC_ARI, MVI_ARI, MVCI_ARI.

function id (n: integer) : rmatrix[l..n,l..n];

Назначение: возвращает единичную квадратную матрицу размерности пхп (предполагается, что п^1).

Определена/переопределена в MV_ARI.

function id (nl, n2: integer) : rmatrix[l..nl,l..n2];

Назначение: возвращает единичную прямоугольную матрицу размерности nl хп2 (предполагается, что п1,п2^1).

Определена/переопределена в MV_ARI.

image J

function image (i: integer) : string;

Назначение: переводит целое значение i в строку с длиной, определяемой форматом вывода по умолчанию для значений типа integer (возможно, дополнив пробелами спереди).

function image (i: integer; width: integer) : string;

Назначение: переводит значение i типа integer в строку с длиной width (возможно, дополнив пробелами спереди).

function image (г: real) : string;

Назначение: переводит значение г типа real в строку с длиной, определяемой форматом вывода по умолчанию для значений типа real (возможно, дополнив пробелами спереди).

function image (г: real; width: integer) : string;

Назначение: переводит значение г типа real в строку с длиной width (возможно, дополнив пробелами спереди).

function image (г: real; width, fracs: integer) : string;

Назначение: переводит значение г типа real в строку с длиной width (возможно, дополнив пробелами спереди) и с fracs цифрами после десятичной точки.

function image (г: real; width, fracs, round: integer) : string;

Назначение: переводит значение г типа real в строку с длиной width (возможно, дополнив пробелами спереди) и с fracs цифрами после десятичной точки, округленное в соответствии с round (< 0 — вниз, =0 — к ближайшему, >0 — вверх).

ival )

function ival (s: string) : integer;

Назначение: переводит первую часть строки s, представляющую числовое значение в соответствии с правилами внешнего представления констант типа integer, в значение типа integer. Пробелы спереди и все символы после значения отбрасываются. Если s не удовлетворяет синтаксису внешнего представления констант типа integer, фиксируется ошибка.

function ival (s: string; var rest: string) : integer;

Назначение: переводит первую часть строки s, представляющую числовое значение в соответствии с правилами внешнего представления констант типа integer, в значение типа integer. Пробелы спереди отбрасываются, а все символы после значения возвращаются в строке rest. Если s не удовлетворяет синтаксису внешнего представления констант типа integer, фиксируется ошибка.

( ^lb )

function lb (var a: Typel; i: integer) : ResType;

Typel: произвольный тип массива.

ResType: тип индексов типа Typel.

Назначение: сокращенная форма записи функции Ibound. Возвращает нижнюю границу i-ro индекса массива а. Если i превосходит число размерностей, фиксируется ошибка.

function lb (var a: Typel) : ResType;

Typel: произвольный тип массива.

ResType: тип индексов типа Typel.

Назначение: сокращенная форма записи функции Ibound. Возвращает нижнюю границу первого индекса массива а.

Ibound

function Ibound (var a: Typel; i: integer) : ResType;

Typel: произвольный тип массива.

ResType: тип индексов типа Typel.

Назначение: возвращает нижнюю границу i-ro индекса массива а. Если i превосходит число размерностей, фиксируется ошибка.

function Ibound (var a: Typel) : ResType;

Typel: произвольный тип массива.

ResType: тип индексов типа Typel.

Назначение: возвращает нижнюю границу первого индекса массива а.

length

function length (s: string) : integer;

Назначение: возвращает текущую длину строкового выражения s.

( )

См. таблицу на стр. 300

loc

function loc (var х: Typel) : integer;

Typel:

произвольный тип.

Назначение: возвращает зависящий от реализации адрес в памяти, по которому расположена переменная х.

1од2

См. таблицу на стр. 300

( 1одю )

См. таблицу на стр. 300

mant

function mant (х: real) : real;

Назначение: возвращает нормализованную мантиссу т (множество значений зависит от реализации) числа х. Если значения хит выходят за определенные реализацией границы, фиксируется ошибка.

Q maxlength

function maxlength (var s: string) : integer;

Назначение: возвращает максимальную длину строковой переменной s.

mid )

function mid (х: Typel) : ResType;

Typel: interval, cinterval, ivector, civector, imatrix, cimatrix.

ResType: тип нижней границы (inf) или верхней границы

(sup) типа Typel.

Назначение: возвращает среднюю точку х (в случае составных типов — для каждой компоненты).

Определена/переопределена в I_ARI, CI_ARI, MVI_ARI, MVCI_ARI.

null J

function null (x: Typel) : rvector[lb(x)..ub(x)];

Typel: rvector, cvector, ivector, civector.

Назначение: возвращает нулевой вектор той же размерности, что и х.

Определена/переопределена в MV_ARI, MVC_ARI, MVI_ARI, MVCI_ARI.

function null (x: Type2) : rmatrix[lb(x)..ub(x),lb(x_I2)..ub(x,2)];

Type2: rmatrix, cmatrix, imatrix, cimatrix.

Назначение: возвращает нулевую матрицу той же размерности, что и х.

Определена/переопределена в MV_ARI, MVC_ARI, MVI_ARI, MVCI_ARI.

function null (x, y: Type2) : rmatrix[lb(x)..ub(x),lb(y,2)..ub(y,2)];

Type2: rmatrix, cmatrix, imatrix, cimatrix.

Назначение: возвращает нулевую матрицу той же размерности, что и произведение матриц х • у.

Определена/переопределена в MV_ARI, MVC_ARI, MVI_ARI, MVCI_ARI.

function null (n: integer) : rmatrix[l..n,l..n];

Назначение: возвращает нулевую квадратную матрицу размерности пхп (предполагается, что п^1).

Определена/переопределена в MV_ARI,

function null (nl, n2: integer) : rmatrix [l..nl,l..n2];

Назначение: возвращает нулевую прямоугольную матрицу размерности пхп (предполагается, что nl, п2 1).

Определена/переопределена в MV_ARI.

odd

function odd (i: integer) : boolean;

Назначение: возвращает true, если i — нечетное число, в обратном случае — false.

ord function ord (x: Typel) : integer;

Typel: integer, boolean, char, перечислимый тип, тип указа

теля.

Назначение: возвращает порядковый номер х или значение указателя, если х принадлежит к типу указателя.

function pos (si, s2: string) : integer;

Назначение: возвращает позицию первого вхождения строки si в строку s2.

pred J

function pred (x: Typel) : Typel;

Typel: integer, real, boolean, char, перечислимый тип.

Назначение: возвращает элемент, предшествующий х. Если такого элемента нет, фиксируется ошибка.

round

function round (х: Typel) : integer;

Typel: integer, real.

Назначение: округление к ближайшему целому числу. Результат удовлетворяет соотношению:

round(x) = sign(x) * trunc(abs(x) + 0.5).

Если такого целого значения нет, фиксируется ошибка.

function rval (s: string) : real;

Назначение: переводит первую часть строки s, представляющую числовое значение в соответствии с правилами для констант типа real, в значение этого типа. Пробелы спереди и все символы после значения отбрасываются. Если s не удовлетворяет синтаксису внешнего представления констант типа real, фиксируется ошибка.

function rval (s: string; var rest: string) : real;

Назначение: переводит первую часть строки s, представляющую числовое значение в соответствии с правилами для констант типа real, в значение этого типа. Пробелы спереди отбрасываются, а все символы после значения возвращаются в строке rest. Если s не удовлетворяет синтаксису внешнего представления констант типа real, фиксируется ошибка.

function rval (s: string; round: integer) : real;

Назначение: переводит первую часть строки s, представляющую числовое значение в соответствии с правилами для констант типа real, в значение этого типа, округленное в зависимости от значения round (< 0 — вниз, = 0 — к ближайшему, >0 — вверх). Пробелы спереди и все символы после значения отбрасываются. Если s не удовлетворяет синтаксису внешнего представления констант типа real, фиксируется ошибка.

function rval (s: string; round: integer; var rest: string) : real;

Назначение: переводит первую часть строки s, представляющую числовое значение в соответствии с правилами для констант типа real, в значение этого типа, округленное в зависимости от значения round (< 0 — вниз, =0 — к ближайшему, >0 — вверх). Пробелы спереди отбрасываются, а все символы после значения возвращаются в строке rest. Если s не удовлетворяет синтаксису внешнего представления констант типа real, фиксируется ошибка.

function sign (х: Typel) : integer;

Typel: integer, real, dotprecision.

Назначение: возвращает знак x ( — 1 для x < 0, 1 для x > 0, 0 для x = 0).

См. таблицу на стр. 300

См. таблицу на стр. 300

С sqr )

См. таблицу на стр. 300

sqrt

См. таблицу на стр. 300 substring function substring (s: string; pos, number: integer) : string;

Назначение: возвращает фрагмент строки s, содержащий number символов, начиная с позиции pos. Если pos больше текущей длины строки s, возвращается пустая строка. Если s содержит меньше, чем pos + number символов, возвращаемая строка соответственно усекается. Если pos < 1, значение pos устанавливается равным 1.

succ )

function succ (х: Typel) : Typel;

Typel: integer, real, boolean, char, перечислимый тип.

Назначение: возвращает элемент, следующий за х. Если такого элемента нет, фиксируется ошибка.

tan J

См. таблицу на стр. 300

tanh

См. таблицу на стр. 300

transp ) function transp (х: Typel) : Typel;

Typel: rmatrix, cmatrix, imatrix, cimatrix.

Назначение: возвращает матрицу, транспонированную по отношению к х.

Определена/переопределена в MV_ARI, MVC_ARI, MVI_ARI, MVCI_ARI.

trunc function trunc (x: Typel) : integer;

Typel: integer, real.

Назначение: округление к значению типа integer путем отбрасывания дробной части. Если такого значения типа integer нет, фиксируется ошибка.

ub

function ub (var a: Typel; i: integer) : ResType;

Typel: произвольный тип массива.

ResType: тип индексов типа Typel.

Назначение: сокращенная форма записи функции abound. Возвращает верхнюю границу i-ro индекса массива а. Если i превосходит число размерностей, фиксируется ошибка.

function ub (var a: Typel) : ResType;

Typel: произвольный тип массива.

ResType: тип индексов типа Typel.

Назначение: сокращенная форма записи функции abound. Возвращает верхнюю границу первого индекса массива а.

ubound ) function ubound (var a: Typel; i: integer) : ResType;

Typel: произвольный тип массива.

ResType: тип индексов типа Typel.

Назначение: возвращает верхнюю границу i-ro индекса массива а. Если i превосходит число размерностей, фиксируется ошибка.

function ubound (var a: Typel) : ResType;

Typel: произвольный тип массива.

ResType: тип индексов типа Typel.

Назначение: возвращает верхнюю границу первого индекса массива а.

vnull

function vnull (n: integer) : rvector[l..n];

Назначение: возвращает нулевой вектор с п компонентами (предполагается, что п^1).

Определена/переопределена в MV_ARI.

Предопределенные математические функции

Аргумент каждой из этих функций может принадлежать типам integer, real, complex, interval и cinterval, т. e. эти функции определены не только для типов integer и real. Они определены также и для типов complex, interval и cinterval — соответствующие определения содержатся в арифметических модулях C_ARI_r I_ARI и CI_ARI.

Интерфейсы и декларации этих функций подробно не описываются, поскольку все они определены с одним формальным параметром. Как правило, тип результата совпадает с типом аргумента, но с аргументами типа integer это выполняется только для функций abs и sqr. Все остальные функции для аргументов типа integer возвращают значения типа real.

В дополнение к описанным функциям, существует функция

arctan2(xl, х2)

с двумя аргументами xl, х2 типа real или interval. Она возвращает значение

arctan(xl/x2).

6. Функции преобразования

В этом разделе приводится упорядоченный по алфавиту список функций преобразования для арифметических типов. Кроме определения (интерфейса) и краткого описания, для каждой функции указывается имя модуля, в котором определяется или совмещается эта функция.

compl j

function compl (xl: Typel; x2: Type2) : ТуреЗ;

Typel: real, interval, rvector, ivector, rmatrix, imatrix.

Type2: real, interval, rvector, ivector, rmatrix, imatrix с той

же структурой (скаляр, вектор, матрица), что и у Typel.

ТуреЗ: соответствующий комплексный тип (complex,

cinterval, cvector, civector, cmatrix, cimatrix).

Назначение: композиция аргументов xl и x2 (вещественная и

мнимая части) в значение соответствующего ком

плексного типа (для векторов и матриц операция выполняется поэлементно).

Определена/переопределена в C_ARI, CI_ARI, MVC_ARI, MVCI_ARI.

function compl (x: Typel) : Type2;

Typel: real, interval, rvector, ivector, rmatrix, imatrix.

Type2: соответствующий комплексный тип (complex,

cinterval, cvector, civector, cmatrix, cimatrix).

Назначение: композиция аргумента x (вещественная часть) и мнимой части, равной нулю, в значение соответствующего комплексного типа (для векторов и матриц операция выполняется поэлементно).

Определена/переопределена в C_ARI, CI_ARI, MVC_ARI, MVCI_ARI.

irn

function im (c: Typel) : Type2;

Определена/переопределена в C_ARI, CI_ARI_r MVC_ARI, MVCI_ARI.

inf

function inf (i: Typel) : Type2;

Typel: interval, cinterval, ivector, civector, imatrix, cimatrix.

Type2: соответствующий вещественный или комплексный

тип (real, complex, rvector, cvector, rmatrix, cmatrix).

Назначение: возвращает нижнюю границу интервального аргумента (для векторов и матриц операция выполняется поэлементно).

Определена/переопределена в I_ARI, CI_ARI, MVI_ARI, MVCI_ARI.

intval J

function intval (xl: Typel; x2: Type2) : ТуреЗ;

Typel: real, complex, rvector, cvector, rmatrix, cmatrix.

Type2: real, complex, rvector, cvector, rmatrix, cmatrix c

той же структурой (скаляр, вектор, матрица), что и у Typel.

ТуреЗ: соответствующий интервальный тип (interval,

cinterval, ivector, civector, imatrix, cimatrix).

Назначение: композиция аргументов xl и x2 (нижней и верхней границы) в значение соответствующего интервального типа (для векторов и матриц операция выполняется поэлементно). Если xl > х2, фиксируется ошибка.

Определена/переопределена в I_ARI, CI_ARI, MVI_ARI, MVCI-ARI.

function intval (х: Typel) : Туре2;

Typel: real, complex, rvector, cvector, rmatrix, cmatrix.

Type2: соответствующий интервальный тип (interval,

cinterval, ivector, civector, imatrix, cimatrix).

Назначение: преобразование аргумента x в интервальное значение с нижней и верхней границами, равными х (для векторов и матриц операция выполняется поэлементно).

Определена/переопределена в I_ARI, CI_ARI, MVI_ARI, MVCI_ARI.

function re (c: Typel) : Type2;

Typel: complex, cinterval, cvector, civector, cmatrix, cimatrix.

Type2: соответствующий вещественный или интервальный

тип (real, interval, rvector, ivector, rmatrix, imatrix).

Назначение: возвращает вещественную часть аргумента (для векторов и матриц операция выполняется поэлементно).

Определена/переопределена в C_ARI, CI_ARI, MVC_ARI, MVCI-ARI.

function sup

Typel:

Туре2:

(i: Typel) : Type2;

interval, cinterval, ivector, civector, imatrix, cimatrix. соответствующий вещественный или комплексный тип (real, complex, rvector, cvector, rmatrix, cmatrix).

Назначение: возвращает верхнюю границу интервального аргумента (для векторов и матриц операция выполняется поэлементно).

Определена/переопределена в I_ARI, CI_ARI, MVI_ARI, MVCI_ARI.

7. Предопределенные процедуры

Этот раздел содержит отсортированный по алфавиту список предопределенных процедур (включая процедуры ввода-вывода) с их декларациями (интерфейсом) и кратким описанием назначения. Для функций, которые определяются или совмещаются в арифметических модулях, приводится имя соответствующего модуля.

dispose procedure dispose (var p: Typel);

Typel: произвольный тип указателя.

Назначение: освобождает участок памяти, занятый объектом по адресу р. Если р = nil, фиксируется ошибка. Процедуру dispose нельзя использовать вместе с процедурой release.

procedure dispose (var p: Typel; cl,c2,.. .,cn: Type2);

Typel: произвольный тип указателя.

Type2: integer, boolean, char, перечислимый тип.

Назначение: освобождает участок памяти, занятый объектом по адресу р. Константы cl,..., сп делают доступными специальные варианты (для записей с вариантами). Если р = nil, фиксируется ошибка. Процедуру dispose нельзя использовать в паре с процедурой release.

get )

procedure get (var f: Typel);

Typel: text, file of ...

Назначение: следующая после текущей компонента файловой переменной f становится текущей. Значение текущей компоненты присваивается буферной переменной ff. Если файл f не определен или находится не в режиме чтения, фиксируется ошибка.

mark

procedure mark (var р: Typel);

Typel: произвольный тип указателя.

Назначение: запоминает текущее состояние «кучи» для использования впоследствии процедурой release.

new procedure new (var p: Typel);

Typel: произвольный тип указателя.

Назначение: создает новый объект по адресу р.

procedure new (var p: Typel; cl,c2,.. .,cn: Type2);

Typel: произвольный тип указателя.

Type2: integer, boolean, char, перечислимый тип.

Назначение: создает новый объект по адресу р. Константы cl,..., сп делают доступными специальные варианты (для записей с вариантами).

page )

procedure page (var f: text);

Назначение: начинает новую страницу в выходном файле f. Если файл f не определен или находится не в режиме записи, фиксируется ошибка.

procedure page;

Назначение: соответствует page(output').

procedure put (var f: Typel);

Typel: text, file of ...

Назначение: значение буферной переменной присваивается

текущей компоненте файла f. Следующая после

текущей компонента становится новой текущей.

Если файл f не определен или находится не в режиме записи, фиксируется ошибка.

read 2)

procedure read (var f: Typel; var x: Type2);

Typel: text, file of ...

Type2: integer, char, string, real, complex, interval, cinterval,

rvector, cvector, ivector, civector, rmatrix, cmatrix, imatrix, cimatrix.

Назначение: ввод одной или нескольких переменных типа Туре2 из файла f (в зависимости от типа Туре2 допускаются спецификации формата, разделенные двоеточиями). Если файл f не определен или находится не в режиме чтения, фиксируется ошибка.

Определена/переопределена в C_ARI, I_ARI, CI_ARI, MV_ARI, MVC_ARI, MVI_ARI, MVCI_ARI.

procedure read (var x: Type2);

Type2: integer, char, string, real, complex, interval, cinterval,

rvector, cvector, ivector, civector, rmatrix, cmatrix, imatrix, cimatrix.

Назначение: соответствует read (input, x).

readin J)

procedure readin (var f: text);

Назначение: заканчивает ввод строки, вводя символ конца строки. Если файл f не определен или находится не в режиме чтения, фиксируется ошибка.

procedure readin;

Назначение: соответствует readln(input').

procedure readin (var f: text; var x: Type2);

Type2: integer, char, string, real, complex, interval, cinterval,

rvector, cvector, ivector, civector, rmatrix, cmatrix, imatrix, cimatrix.

Назначение: соответствует read(f, x), после чего следует readln(F). procedure readin (var x: Type2);

Type2: integer, char, string, real, complex, interval, cinterval,

rvector, cvector, ivector, civector, rmatrix, cmatrix, imatrix, cimatrix.

Назначение: соответствует read(x), после чего следует readin.

release J

procedure release (var p: Typel);

Typel: произвольный тип указателя.

Назначение: возобновляет старое состояние «кучи», запомненное процедурой mark. Все переменные, созданные с момента вызова mark, уничтожаются, освобождая память. Указатель р должен иметь то же значение, что и указатель, использованный при последнем вызове процедуры mark. Процедуру mark нельзя использовать в паре с dispose.

reset J

procedure reset (var f: Typel);

Typel: text, file of ...

Назначение: файл f инициализируется для чтения (ввода).

procedure reset (var f: Typel; s: string);

Typel: text, file of ...

Назначение: файл f инициализируется для чтения (ввода), при этом ему ставится в соответствие физический (внешний) файл с именем s.

rewrite )

procedure rewrite (var f: Typel);

Typel: text, file of ...

Назначение: файл f инициализируется для записи (вывода).

procedure rewrite (var f: Typel; s: string);

Typel: text, file of ...

Назначение: файл f инициализируется для записи (вывода), при этом файлу f ставится в соответствие физический (внешний) файл с именем s.

setlength J)

procedure setlength (var s: Typel; i: Type2);

Typel: string[m] или string.

Type2: O..m или 0..M.

Назначение: текущая длина строковой переменной s устанавливается равной i, причем 0 i т или 0 С i М соответственно, где М — зависящая от реализации максимальная длина строковой переменной. Если i превышает максимальную длину, фиксируется ошибка.

write у

procedure write (var f: Typel; x: Type2);

Typel: text, file of ...

Type2: integer, boolean, char, string, real, complex, interval,

cinterval, rvector, cvector, ivector, civector, rmatrix, cmatrix, imatrix, cimatrix.

Назначение: вывод значений одного или нескольких выражений типа Туре2 в файл f (в зависимости от типа Туре2 допускаются спецификации формата, разделенные двоеточиями). Если файл f не определен или находится не в режиме записи, фиксируется ошибка.

Определена/переопределена в C_ARI, I_ARI, CI_ARI, MV_ARI, MVC_ARI, MVI_ARI, MVCI_ARI.

procedure write (х: Туре2);

Туре2: integer, boolean, char, string, real, complex, interval,

cinterval, rvector, cvector, ivector, civector, rmatrix, cmatrix, imatrix, cimatrix.

Назначение: соответствует write(output, x).

writein J

procedure writein (var f: text);

Назначение: завершение строки выходного файла символом конца строки. Если файл f не определен или находится не в режиме записи, фиксируется ошибка.

procedure writein;

Назначение: соответствует writelnfputput).

procedure writein (var f: text; x: Type2);

Type2: integer, boolean, char, string, real, complex, interval,

cinterval, rvector, cvector, ivector, civector, rmatrix, cmatrix, imatrix, cimatrix.

Назначение: соответствует write(f, x), за которым следует writeln(T).

procedure writein (x: Type2);

Type2: integer, boolean, char, string, real, complex, interval,

cinterval, rvector, cvector, ivector, civector, rmatrix, cmatrix, imatrix, cimatrix.

Назначение: соответствует write(x), за которым следует writein.

• 8. #-выражения
• 8.1 Вещественные и комплексные #-выражения

Синтаксис: # -символ ( точное-выражение )

Под «вызовами специальных функций» подразумеваются вызовы функций compl, re, im, conj, intval, inf, sup, id, transp, herm, а также функций преобразования типа rvector, cvector, ivector и civector.

8.2 Вещественные и комплексные интервальные #-выражения

Синтаксис: # # ( точное-выражение )

Под «вызовами специальных функций» подразумеваются вызовы функций compl, re, ini, conj, intval, inf, sup, id, transp, herm, а также функций преобразования rvector, cvector, ivector и civector.

Дополнение

Новые возможности для работы с динамическими массивами

Д. В. Ширяев

В последних реализациях PASCAL-XSC расширены синтаксис и семантика языковых конструкций, имеющих отношение к работе с динамическими массивами. В числе прочего

• • добавлены новые процедуры для явного первоначального размещения и явного переразмещения динамических массивов;
• • появилась возможность переразмещать массивы с новыми диапазонами изменения индексов в любой точке программы;
• • выполнение оператора присваивания с динамическими массивами слева и справа от знака присваивания влечет теперь размещение целевого массива, если он не был размещен прежде;
• • динамические массивы теперь могут быть компонентами других составных типов данных.

Несмотря на перечисленные нововведения, сохранена совместимость с прежним описанием языка.

Синтаксис объявления динамических массивов выглядит теперь следующим образом:

| dynamic array [СписокРазмерностей] of ТипЭлементов

СписокРазмерностей — это или список, состоящий, как и раньше, из знаков *, или список диапазонных типов, производных от типа integer. СписокРазмерностей всегда состоит хотя бы из одного элемента. Если должно быть специфицировано более одного элемента, то все они разделяются запятыми. Диапазонные типы в списке размерностей специфицируются либо своими идентификаторами, либо явными указаниями диапазонов:

I ЦелочисленноеВыражение .. ЦелочисленноеВыражение

Таким образом, теперь имеются две возможности для объявления динамических массивов. Первая — объявление согласно старому правилу: type vector = dynamic array [*] of real;

вторая — указание базового диапазона изменения индексов:

type vec = dynamic array [1 .. 10] of real;

{ or }

type vec = vector [1 .. 10] ;

При объявлении динамических массивов с размерностью больше единицы не разрешается смешивать звездочки и явно указанные диапазоны изменения индексов в пределах одной декларации.

1. Объявление переменных

Синтаксис объявления переменных расширяется следующим образом:

Ivar СписокИдентификаторов : ИдентификаторДинамического-Типа [СписокРазмерностей];

Как обычно, переменные могут быть объявлены с использованием предопределенного или определенного пользователем типа:

Ivar СписокИдентификаторов : ИдентификаторДинамического-

Типа

Эти правила предоставляют несколько вариантов объявления переменных:

• с явным указанием диапазонов изменения индексов: var v : vector [1 .. 10] ;

{ or }

var v : dynamic array [1 .. 10] of real;

• — так объявленные динамические массивы автоматически размещаются при входе в подпрограмму, в которой они объявлены, и уничтожаются при выходе из нее, то есть ведут себя так же, как динамические массивы в предыдущих версиях языка. Кроме того, объявленные этим способом массивы могут быть переразмещены во время исполнения подпрограммы, в которой они были объявлены;
• • без явного указания диапазона изменения индексов:

var v : vector;

{ or }

var v : dynamic array [*] of real;

— в этом случае переменная v должна быть явно размещена пользователем. Тем не менее, она будет автоматически уничтожена при выходе из подпрограммы, в которой была объявлена. Объявленные таким способом массивы также могут быть переразмещены пользова

телем;

• с использованием базовых диапазонов изменения индексов:

var v : vec;

{ or }

var v : vec [1 .. 20];

• — в обоих случаях будет произведено автоматическое размещение и уничтожение массива. Однако размещение происходит по-разному. При неуказании границ изменения индекса будет использован его базовый диапазон, в противном случае базовый диапазон замещается специфицированным. Такой массив также может быть переразмещен пользователем.
• 2. Управление памятью

В этом разделе представлен набор подпрограмм для управления памятью, необходимой для размещения динамических массивов.

Первая подпрограмма — это процедура allocate, явно размещающая динамический массив с указанными диапазонами изменения индексов:

? allocate (ДинамическаяПеременная, СписокРазмерностей... {не пустой} );

Длина списка размерностей должна быть равна длине, указанной при объявлении массива. Массив размещается с указанными границами; если он уже ранее был размещен, то выделенная ему память освобождается.

Следующая процедура предоставляет возможность явного освобождения отведенной под массив памяти:

| free (ДинамическаяПеременная);

После вызова процедуры free границы индексов массива-параметра не определены до следующего размещения. Если массив-параметр не был размещен до вызова free, то при вызове этой процедуры ничего не происходит.

Попытка доступа к неразмещенному массиву может иметь нежелательные последствия, поэтому для определения того, размещен массив или нет, введена функция

| allocated (ДинамическаяПеременная)

с результатом типа boolean. Функция allocated возвращает true, если аргумент был размещен, и false в противном случае.

3. Примеры

Пример 1. Размещение одномерного динамического массива, содержащего компоненты некоторого вектора, его обработка, удвоение длины и передача на последующую обработку.

type vector = dynamic array [*] of real;

procedure double_vector (n : integer);

var local : vector;

begin

allocate (local, 1 .. n);

{ обработка }

free (local); {можно опустить}

allocate (local, 1 .. 2 * n);

{ еще обработка }

end;

Первый вызов allocate размещает массив local с индексами в диапазоне от 1 до п. Выполнив несколько операторов, мы освобождаем память из-под массива local вызовом процедуры free. В данном случае освобождать память необязательно, поскольку последующий вызов allocate сделал бы это автоматически.

Пример 2. Ввод одномерного массива чисел типа real из текстового файла.

N чисел типа real должны быть прочитаны из текстового файла в одномерный массив. В начале файла находится количество чисел, а затем идут сами числа. Возможность переразмещать массивы сильно облегчает решение этой задачи:

procedure read (var f : text; var v : vector);

var i, n : integer;

begin

if allocated (v) then free(v);

read (f, n);

allocate (v, 1 .. n);

for i := lb(v) to ub(v) do read (f, v[i]) end;

Оператор if приведен для демонстрации использования процедуры allocated и не является здесь обязательным.

4. Присваивание динамических массивов

Семантика присваивания совместимых динамических массивов

А := В;

не меняется за следующими исключениями:

• если не размещен массив В, то на этапе выполнения программы фиксируется ошибка;

• если не размещен массив А, то место для него отводится до выполнения присваивания, и он будет иметь тот же самый размер и диапазон индексов, что и В.

Если при компиляции установлен режим, при котором в процессе выполнения проверяется соответствие индекса реальной размерности массива, то попытка доступа к неразмещенному массиву вызывает ошибку времени выполнения. В противном случае эффект не определен.

5. Динамические массивы как компоненты других типов

Динамические массивы теперь могут быть компонентами составных типов — статических массивов и записей. Достигнуто это не за счет изменения синтаксиса языка, а лишь за счет расширения семантики в описаниях типов. Объявление составного типа с динамической компонентой следует общим правилам объявления динамических массивов. В частности, могут быть указаны диапазоны изменения индексов.

Пример:

type rec = record

a, b : real;

v : dynamic array [*] of real

end;

{ or }

type rec = record

a, b : real;

v : dynamic array [1 .. 5] of real end;

Размещение и освобождение динамических компонент также следует общим правилам для динамических массивов.

Особого внимания требуют программы, использующие указатели на динамические массивы. Рассмотрим пример.

type dyn = dynamic array [*] of integer;

dyn2 = dynamic array [1 .. 10] of integer;

var pl = “dyn;

p2 = “dyn2;

begin

new (p2); {автоматическое размещение p2“}

new (pl); {размещение только дескриптора}

allocate (pl“, 1 .. 10); {явное размещение pl“} {последующие операторы}

end

Переменная р2 указывает на динамический массив с базовыми границами от 1 до 10. Следовательно, при вызове new происходит автоматическое размещение динамического массива, на который указывает р2. При вызове же new(pl) этого не происходит, поскольку pl указывает на динамический массив без базового диапазона границ. В этом случае выполнение new приводит к созданию лишь дескриптора массива. Размещение в памяти должно быть осуществлено явным образом — при помощи процедуры allocate.

Литература

[1] Adams, Е., Kulisch, U. (Eds) Scientific Computing with Automatic Result Verification. Academic Press, New York, 1993.

[2] Alefeld, G., Herzberger, J. Einfiihrung in die Intervallrechnung. Bibliographisches Institut, Mannheim, 1974.

[3] Alefeld, G., Herzberger, J. Introduction to Interval Computations. Academic Press, New York, 1983.

[4] American National Standards Institute / Institute of Electrical and Electronic Engineers: A Standard for Binary Floating-Point Arithmetic. ANSI/IEEE Std. 754-1985, New York, 1985.

[5] Bauch, H., Jahn, K.-U., Oelschlagel, D., Susse, H., Wiebigke, V. Intervall-mathematik. Teubner, Leipzig, 1987.

[6] Bleher, J. H., Rump, S. M., Kulisch, U., Metzger, M., Ullrich, Ch., Walter, W. FORTRAN-SC: A Study of a FORTRAN Extension for Engineering/Scientific Computation with Access to ACRITH. Computing 39, 1987, pp. 93-110.

[7] Bohlender, G., Rail, L„ Ullrich, Ch., Wolff von Gudenberg, J. PASCAL-SC: A Computer Language for Scientific Computation. Academic Press, New York, 1987.

[8] Bohlender, G„ Rail, L„ Ullrich, Ch., Wolff von Gudenberg, J. PASCAL-SC— Wirkungsvoll programmieren, kontrolliert rechnen. Bibliographisches Institut, Mannheim, 1986.

[9] Bohm, H. Auswertung arithmetischer Ausdriicke mit maximaler Genauigkeit. In: Kulisch, U., Ullrich, Ch. (Eds) Wissenschaftliches Rechnen und Programmiersprachen. Berichte des German Chapter of the ACM, Band 10, Teubner, Stuttgart, 1982, pp. 175-184.

[10] British Standards Institution. Specification for Computer Programming Language PASCAL. BS 6192:1982, UDC 681.3.06, PASCAL:519.682, London, 1982.

[11] Hammer, R., Hocks, M., Kulisch, U., Ratz, D. Numerical Toolbox for Verified Computing I—Basic Numerical Problems. Springer-Verlag, Heidelberg, 1993.

[12] Hammer, R., Hocks, M., Kulisch, U., Ratz, D. C++ Toolbox for Verified Computing I—Basic Numerical Problems. Springer-Verlag, Heidelberg, 1995.

[13] IBM High-Accuracy Arithmetic Subroutine Library (ACRITH). General Information Manual, GC 33-6163-02, 3rd Edition, 1986.

[14] IBM High-Accuracy Arithmetic Subroutine Library (ACRITH). Program Description and User's Guide, SC 33-6164-02, 3rd Edition, 1986.

[15] IBM High Accuracy Arithmetic—Extended Scientific Computation (ACRITH-XSC), Reference. SC 33-6462-00, IBM Corp., 1990.

[16] Jensen, K., Wirth, N. PASCAL User Manual and Report. ISO PASCAL Standard, 3rd ed., Springer, Berlin, 1985.

[17] Kaucher, E., Klatte, R., Ullrich, Ch. Programmiersprachen im Griff—Band 2: PASCAL. Bibliographisches Institut, Mannheim, 1981.

[18] Kaucher, Е., Klatte, R., Ullrich, Ch., Wolff von Gudenberg, J. Programmiersprachen im Griff—Band 4: ADA. Bibliographisches Institut, Mannheim, 1983.

[19] Kaucher, E., Kulisch, U., Ullrich, Ch. (Eds) Computer Arithmetic—Scientific Computation and Programming Languages. Teubner, Stuttgart, 1987.

[20] Kaucher, E., Miranker, W. L. Self-Validating Numerics for Function Space Problems. Academic Press, New York, 1984.

[21] Kaucher, E., Rump, S. M. E-Methods for Fixed Point Equation f(x) = x. Computing 28, 1982, pp. 31-42.

[22] Kieling, I., Lowes, M., Paulik, A. Genaue Rechnerarithmetik—Intervallrechnung und Programmieren mit PASCAL-SC. Teubner, Stuttgart, 1988.

[23] Kirchner, R., Kulisch, U. Accurate Arithmetic for Vector Processors. Journal of Parallel and Distributed Computing 5, 1988, pp. 250-270.

[24] Klatte, R„ Kulisch, U., Neaga, M„ Ratz, D„ Ullrich, Ch. PASCAL-XSC— Sprachbeschreibung mit Beispielen. Springer-Verlag, Heidelberg, 1991.

[25] Klatte, R„ Kulisch, U„ Neaga, M„ Ratz, D., Ullrich, Ch. PASCAL-XSC—Language Reference with Examples., Springer-Verlag, New York, 1992.

[26] Klatte, R., Ullrich, Ch. Programmiersprachen im Griff—Band 9: MODULA-2. Biblio-graphisches Institut, Mannheim, 1988.

[27] Knuth, D. E. The Art of Computer Programming. Vol. 2: Seminumerical Algorithms. Addison Wesley, Reading, Massachusetts., 1981.

[28] Kramer, W., Kulisch, U., Lohner, R. Numerical Toolbox for Verified Computing II— Advanced Numerical Problems. Springer-Verlag, Heidelberg, 1995.

[29] Kulisch, U. Grundlagen des Numerischen Rechnens—Mathematische Begriindung der Rechnerarithmetik. Reihe Informatik, Band 19, Bibliographisches Institut, Mannheim, 1976.

[30] Kulisch, U. (Ed.) PASCAL-SC: A PASCAL Extension for Scientific Computation, Information Manual and Floppy Disks, Version ATARI ST. Teubner, Stuttgart, 1987.

[31] Kulisch, U. (Ed.) PASCAL-SC: A PASCAL Extension for Scientific Computation, Information Manual and Floppy Disks, Version IBM PC/AT (DOS). Teubner, Stuttgart, 1987.

[32] Kulisch, U. (Ed.) Wissenschaftliches Rechnen mit Ergebnisverifikation—Eine Ein-fiihrung. Akademie Verlag, Ost-Berlin, Vieweg, Wiesbaden, 1989.

[33] Kulisch, U., Miranker, W. L. Computer Arithmetic in Theory and Practice. Academic Press, New York, 1981.

[34] Kulisch, U., Miranker, W. L. The Arithmetic of the Digital Computer: A New Approach. SIAM Review 28 (1), 1986, pp. 1-140.

[35] Kulisch, U., Miranker, W. L. (Eds) A New Approach to Scientific Computation. Academic Press, New York, 1983.

[36] Kulisch, U., Stetter, H. J. (Eds) Scientific Computation with Automatic Result Verification. Computing Suppl. 6, Springer-Verlag, Vienna, 1988.

[37] Kulisch, U., Ullrich, Ch. (Eds) Wissenschaftliches Rechnen und Programmiersprachen. Berichte des German Chapter of the ACM, Band 10, Teubner, Stuttgart, 1982.

[38] Mayer, G. Grundbegriffe der Intervallrechnung. In: Kulisch, U. (Ed.) Wissenschaftliches Rechnen mit Ergebnisverifikation—Eine Einfiihrung, Akademie Verlag, Ost-Berlin, Vieweg, Wiesbaden, 1989, pp. 101-118.

[39] Moore, R. E. Interval Analysis. Prentice Hall, Engelwood Cliffs, New Jersey, 1966.

[40] Moore, R. E. Methods and Applications of Interval Analysis. SIAM, Philadelphia, Pensylvania, 1979.

[41] Moore, R. E. (Ed.) Reliability in Computing: The Role of Interval Methods in Scientific Computations. Academic Press, New York, 1988.

[42] Neaga, M. PASCAL-SC—Eine PASCAL-Erweiterung fur wissenschaftliches Rechnen. In: Kulisch, U. (Ed.) Wissenschaftliches Rechnen mit Ergebnisverifikation—Eine Einfiihrung, Akademie Verlag, Ost-Berlin, Vieweg, Wiesbaden, 1989, pp. 69-84.

[43] Neumaier, A. Interval Methods for Systems of Equations. Cambridge University Press, Cambridge, 1990.

[44] Nickel, K. (Ed.) Interval Mathematics. Proceedings of the International Symposium, Karlsruhe 1975, Springer-Verlag, Vienna, 1975.

[45] Nickel, K. (Ed.) Interval Mathematics 1980. Proceedings of the International

Symposium, Freiburg 1980, Academic Press, New York, 1980.

[46] Nickel, K. (Ed.) Interval Mathematics 1985. Proceedings of the International

Symposium, Freiburg 1985, Springer-Verlag, Vienna, 1986.

[47] Numerik Software GmbH. PASCAL-XSC: A PASCAL Extension for Scientific Computation. User's Guide., Numerik Software GmbH, P.O.Box 2232, D-76492 Baden-Baden, 1991.

[48] Rail, L. B. Automatic Differentiation, Techniques and Applications. Lecture Notes in Computer Science 120, Springer, Berlin, 1981.

[49] Ratschek, H., Rokne, J. Computer Methods for the Range of Functions. Ellis Horwood Limited, Chichester, 1984.

[50] Rump, S. M. Lbsung linearer und nichtlinearer Gleichungssysteme mit maximaler Genauigkeit. In: Kulisch, U., Ullrich, Ch. (Eds) Wissenschaftliches Rechnen und Programmiersprachen. Berichte des German Chapter of the ACM, Band 10, Teubner, Stuttgart, 1982, pp. 147-174.

[51] Rump, S. M. Wie zuverldssig sind die Ergebnisse unserer Rechenanlagen. In: Jahrbuch Uberblicke Mathematik, Bibliographisches Institut, Mannheim, 1983.

[52] Rump, S. M. Solving Algebraic Problems with High Accuracy. In: Kulisch, U., Miranker, W. L. (Eds) A New Approach to Scientific Computation, Academic Press, New York, 1983, pp. 51-120.

[53] Stoer, J., Bulirsch, R. Introduction to Numerical Analysis. Springer-Verlag, New York, 1980.

[54] Thieler, P. Technical Calculations by Means of Interval Mathematics. In: Nickel, K. (Ed.) Interval Mathematics 1985, Lecture Notes in Computer Science, Springer Verlag, Berlin, 1986, pp. 197-208.

[55] Ullrich, Ch. (Ed.) Computer Arithmetic and Self-Validating Numerical Methods. Academic Press, San Diego, 1990.

[56] Ullrich, Ch. (Ed.) Contributions to Computer Arithmetic and Self-Validating Numerical Methods. J. C. Baltzer AG, Scientific Publishing Co., IMACS, Basel, 1990.

[57] van Wijngaarden, A., Mailloux, B. J., Peck, J. E. L., Kester, С. H. A. Report on the Algorithmic Language ALGOL-68. Numerische Mathematik 14, 1969, pp. 79-218.

[58] Wilkinson, J. H. Rounding Errors in Algebraic Processes. Prentice Hall, Englewood Cliffs, New Jersey, 1963.

[59] Zurmuhl, R., Falk, S. Matrizen und ihre Anwendungen. Teil 2: Numerische Methoden. Springer-Verlag, Heidelberg, 1984.

Алфавитный указатель

abs (функция), 90, 91, 173, 177, 183, 314

and (операция), 74

arccos (функция), 80, 159, 163, 169, 314

arccot (функция), 80, 159, 163, 169, 314

arcosh (функция), 80, 159, 163, 169, 314

arcoth (функция), 80, 159, 163, 169, 314

arcsin (функция), 80, 159, 163, 169, 314

arctan2 (функция), 80, 159, 163, 169, 315

arctan (функция), 77, 159, 163, 169, 314

arg (функция), 159, 169, 302

array (зарезервированное слово), 53

arsinh (функция), 80, 159, 163, 169, 314

artanh (функция), 80, 159, 163, 169, 314

begin (зарезервированное слово), 108

blow (функция), 164, 169, 184, 191, 302

boolean (тип), 50

char (тип), 50

chr (функция), 82, 302

cimatrix (тип), 66, 185

cintcrval (тип), 66, 165

ci vector (тип), 66, 185

crnatrix (тип), 66, 175

complex (тип), 65, 157

compl (функция), 158, 168, 177, 178, 189, 315

comp (функция), 80, 303

conj (функция), 159, 169, 179, 191, 303

const (зарезервированное слово), 48 cosh (функция), 80, 159, 163, 169, 314 cos (функция), 77, 159, 163, 169, 314 coth (функция), 80, 159, 163, 169, 314 cot (функция), 80, 159, 163, 169, 314 cvector (тип), 66, 175

diam (функция), 164, 169, 184, 191, 303

dispose (процедура), 68, 318

div (операция), 75

dotprecision (тип), 43, 52, 90

downto (зарезервированное слово), 85, 111

do (зарезервированное слово), 109, 111 dynamic (зарезервированное слово), 57

else (зарезервированное слово), 108 end (зарезервированное слово), 59, 108

eof (функция), 63, 81, 304

eoln (функция), 64, 81, 304

ехрЮ (функция), 80, 158, 163, 169, 314

ехр2 (функция), 80, 158, 163, 169, 314

expo (функция), 76, 80, 304

ехр (функция), 77, 159, 163, 169, 314 external-декларация, 127

false (логическая константа), 50

file (зарезервированное слово), 62 forward-декларация, 127

function (зарезервированное слово), 119

get (процедура), 63, 318

global-декларация, 136

herm (функция), 179, 191, 305

id (функция), 174, 179, 184, 191, 305

if-statement, 108

image (функция), 140, 305

imatrix (тип), 66, 180

im (функция), 158, 168, 177, 178, 189, 316

inf (функция), 162, 168, 182, 183, 189, 316

input (файловая переменная), 101

integer (тип), 49

interval (тип), 65, 160

intval (функция), 162, 168, 182, 183, 189, 316

in (операция), 61, 74, 75, 161, 166

ival (функция), 76, 141, 306

ivector (тип), 66, 180

label (зарезервированное слово), 107

Ibound (функция), 56, 76, 81 — 83, 307

lb (функция), 76, 81—83, 307

length (функция), 140, 307

In (функция), 77, 159, 163, 169, 314

loc (функция), 76, 308

loglO (функция), 80, 158, 163, 169,

314

log2 (функция), 80, 158, 163, 169, 314

mant (функция), 80, 308

mark (процедура), 69, 318

maxint (константа), 49

maxlength (функция), 141, 308

mid (функция), 163, 169, 184, 191, 308

module (зарезервированное слово),

136

mod (операция), 75

new (процедура), 67, 318

nil (зарезервированное слово), 67

not (операция), 74

null (функция), 174, 179, 184, 191,

309

odd (функция), 81, 309

of (зарезервированное слово), 53

operator (зарезервированное слово), 123, 134

ord (функция), 76, 310

or (операция), 74

output (файловая переменная), 101

packed (зарезервированное слово), 58 page (процедура), 319

pos (функция), 141, 310

pred (функция), 76, 79, 81—83, 310 priority (зарезервированное слово),

124

procedure (зарезервированное слово), 114

program (зарезервированное слово), 112

put (процедура), 63, 319

readin (процедура), 103, 320

read (процедура), 102, 131, 159, 164, 170, 175, 179, 185, 192, 319

real (тип), 49, 51

real выражения, 77

record (зарезервированное слово), 59 release (процедура), 69, 320 reset (процедура), 63, 102, 320 rewrite (процедура), 102, 321

ге (функция), 158, 168, 177, 178, 189, 317

rmatrix (тип), 66, 171

round (функция), 76, 310

rval (функция), 80, 141, 310

rvector (тип), 66, 171

setlength (процедура), 142, 321

sign (функция), 76, 82, 311

sinh (функция), 80, 159, 163, 169, 314 sin (функция), 77, 159, 163, 169, 314 sqrt (функция), 77, 159, 163, 169, 314 sqr (функция), 76, 77, 159, 163, 169,

314

string (тип), 58, 139

substring (функция), 140, 312

succ (функция), 76, 79, 81 -83, 312 sum-запись, 85

sup (функция), 162, 168, 182, 183, 189, 317

tanh (функция), 66, 145, 149, 155, 314

tan (функция), 80, 159, 163, 169, 314 text (тип), 64

then (зарезервированное слово), 108 to (зарезервированное слово), 85, 111 transp (функция), 174, 179, 184, 191, 312

true (логическая константа), 50 trunc (функция), 76, 313

type (зарезервированное слово), 48

ubound (функция), 56, 76, 81—83, 313

ub (функция), 76, 81—83, 313

Ulp, 78

until (зарезервированное слово), ПО

var (зарезервированное слово), 48,

115

vnull (функция), 174, 313

writein (процедура), 104, 322 write (процедура), 103, 131, 159, 164, 170, 175, 179, 185, 192, 321

Антисимметричность, 32, 34 Аргумент тригонометрического представления комплексного числа, 158

Арифметика, 42 вещественная векторно-матричная, 171 дифференциальная (упражнение), 240 интервальная, 160 интервальная

векторно-матричная, 180 комплексная, 156 комплексная

векторно-матричная, 175 комплексная интервальная, 165 комплексная интервальная

векторно-матричная, 185 рациональная (упражнение), 261 стандартные типы, 64 Арифметические модули, 151 Арифметические операции, 153, 298

Базовый тип, 61 Безымянный тип, 49, 55, 70

Библиотека численных методов, 199 Бинарные операции, 74, 123 Биномиальный коэффициент, 207 Буферные переменные, 62

Варианты записи, 60

Ввод

вещественных векторов, 175

вещественных матриц, 175 интервалов, 164

интервальных векторов, 185

интервальных матриц, 185 комплексных векторов, 179 комплексных интервалов, 170

комплексных интервальных векторов, 192

комплексных интервальных матриц, 192

комплексных матриц, 179 комплексных чисел, 159 символов, 143 строк, 145

Ввода-вывода операторы, 117

Векторно-матричное произведение, точное, 93

Векторное произведение, 212

Верификация, 193

Вещественная часть комплексного числа, 65

Включающие алгоритмы, 43 Включение, 198

Влияние погрешностей округления (упражнение), 204

Вывод

вещественных векторов, 175

вещественных матриц, 175 интервалов, 164

интервальных векторов, 185

интервальных матриц, 185 комплексных векторов, 179 комплексных интервалов, 170

комплексных интервальных векторов, 192

комплексных интервальных матриц, 192

комплексных матриц, 179 комплексных чисел, 159

Вызов по значению, 70, 107, 115, 116, 130, 135

Вызов по ссылке, 70, 107, 115, 116, 130 модифицированный, 107, 116, 119, 125, 127 Вызов функции, 119 Выполнение программы, ИЗ Выражения, 72 высокоточные, 43, 84, 90, 323 вычисление, 73 динамические массивы, 88 для арифметических типов, 87 для структурированных типов, 87 записи, 89 логические, 81 массивы, 88 множества, 89 перечислимого типа, 83 понятие, 72 построение, 152 символьные, 82 стандартные, 73 строки, 89 строкового типа, 139 типа integer, 75 типа real, 77 точные, 84, 92 указатели, 87, 90

Высокоточные выражения, 43, 84 вещественные, 99 для арифметических типов, 91 для векторов, 93 для матриц, 94 интервальные, 100, 101 комплексные, 92, 99 комплексные интервальные, 92, 100, 101 обобщенные, 90 общий обзор, 99 операнды, 96 типа complex, 323 типа interval, 91, 324 типа real, 84, 91, 323 Вычисление выражений, 73 Вычисление полиномов (упражнение), 265

Вычисления с интервальными матрицами (упражнение), 238

Вычитание без ошибок округления, 85

Главная программа, ИЗ Глобальные объекты, 136 Границы индексов, 56 доступ, 56

Декларация external-, 127 forward-, 127 global-, 136

Деление комплексных чисел (упражнение), 226

Диаметр интервала, 163 Диапазонный тип, 51 Динамические массивы, 41, 56, 117 148 выражения, 88 декларация, 57 использование, 148 определение типа, 57

Динамические строки символов, 58 Длина строки, 143

Единичная матрица, 174, 179, 184, 191

Записи выражения, 89 компоненты, 59 с вариантами, 60 тип, 59

Запись в файл, 63 Зарезервированные слова, 45, 295 and, 74 array, 53 begin, 108 case, 60, 108 const, 48 div, 75 downto, 85, 111 do, 109, 111 dynamic, 57 else, 108 end, 59, 108

Литеральные константы, 47

Литература, 331

Логическая импликация, 81

Логическая эквивалентность, 81

Логические выражения, 81

Локальные объекты, 115

Максимальная точность, 32, 34, 80, 151

Мантисса, 78

Массивы, 53

выражения, 88

выражения, динамические, 88 динамические, 41, 56, 117, 148 тип, 53

Математически точные операции, 85, 91

Матрицы Бутройда-Деккера (упражнение), 207

Метки, 107

Метод Ньютона, 243

Метод Ньютона с автоматическим дифференцированием (упражнение), 243

Метод Рунге-Кутты, 172, 182

Метод Рунге-Кутты (упражнение), 258

Метод итераций (упражнение), 258

Мнимая часть комплексного числа, 65

Множества

выражения, 89

конструкторы, 89

объединение, 74, 90

пересечение, 74, 90

разность, 74, 90 тип, 61

Модифицированный вызов по ссылке, 107, 116, 119, 125, 127

Модули, ИЗ, 136

арифметические, 151 библиотека для решения

численных задач, 198

декларация, 136

иерархия, 138

область деклараций, 139

область определений, 139 обработка, 114 операторная часть, 139 реализация, 139 C_ARI, 156 C1_ARI, 165 I_ARI, 160 MV_ARI, 171 MVC_ARI, 175 MVCI_ARI, 185 MVI_ARI, 180

Модульность, 40

Монотонность, 32, 34

Мост для измерения переменного тока (упражнение), 231

Начальные значения, 111 Начальные условия, 109 Невязка, 174, 184

Нелокальные объекты, 115 Нормализованные числа с плавающей точкой, 78

Нулевая матрица, 174, 179, 184, 191 Нулевой вектор, 174, 179, 184, 191

Область деклараций

в стандартном Паскале, 113 в PASCAL-XSC, 114 Обобщенные высокоточные выражения, 90 Оболочка, 198

интервальная, 161 Обработка текстов, 139 Объекты

глобальные, 136 импорт, 137 локальные, 115 нелокальные, 115 экспорт, 136, 137

Округление, 42 вверх, 78 вниз, 78 до интервала, 91, 92 направленное, 92 режим, 105

Округляемые константы, 51 Операнды

в высокоточных выражениях, 96 Оператор выбора, 108

с альтернативой else, 109 для строк, 142

Операторная часть

модуля, 139

программы, 113 Операторы, 101 case, 108 goto, 107 if, 108 with, 111 безусловного перехода, 107 помеченные, 107 присваивания, 101, 134 простые, 101 процедуры, 106, 116 пустой, 106 составные, 107 структурированные, 101 условные, 108 цикла, 109

Операторы ввода, 101, 102, 117 read, 102, 159, 164, 170, 175, 179, 185, 192 readln, 103 reset, 102

Операторы вывода, 101, 103, 117 page, 104 rewrite, 102 writein, 104 write, 103, 159, 164, 170, 175, 179, 185, 192

Операторы цикла, 109

for, ПО

repeat, ПО while, 109

Операции, 123, 297

and, 74

div, 75

in, 61, 161, 166

mod, 75

not, 74

or, 74

арифметические, 74, 75, 153, 157, 166, 171, 176, 180, 185, 298

бинарные, 74, 123 вызов, 125 декларация, 123 затенение, 124 логические, 74 математически точные, 85, 91 модуля C1_ARI, 166 модуля C_ARI, 157 м о дуля I _AR 1, 161

модуля MVCI_ARI, 185

модуля MVC_ARI, 176

модуля MVI_ARI, 180

модуля MV_ARI, 171

не имеющие результата, 134 основные, 297

отношения, 74, 75, 154, 155, 157, 161, 166, 172, 177, 181, 188, 299

предопределенные, 126 присваивания, 134, 156, 158, 162,

168, 173, 178, 183, 190, 300 рекурсивные, 126

совмещение, 124, 128, 134 тело, 123

указатель, 297

универсализация описания, 38 унарные, 60, 61, 109 над множествами, 74

Операции с файлом, 62

reset, 62

Определение типа, 48

Оптическая линза (упражнение), 233

Отношение принадлежит, 161

Отношение содержится внутри, 166, 181, 188

Отношение содержится в, 161, 166, 181, 188

Основание степени, 78

Основные символы, 45

Открытие файлов, 102

Параллелепипед, площадь поверхности, 211

Параллельность и пересечение прямых (упражнение), 214

Параметры

список, 115

фактические, 106, 116 формальные, 106, 115, 116

Переменные, 48

input, 101

output, 101

декларация, 48, 49 компонентные, 54

декларация, 114

для решения типичных задач, 198

предопределенные, 118 рекурсивные, 116 совмещение, 128 указатель, 317

Прямоугольное представление комплексного интервала, 165

Пустой оператор, 106

Пустой цикл, 111

Разделительный символ, 113 Расписание движения поезда (упражнение), 218

Расчет электрической цепи (упражнение), 227

Рациональная арифметика (упражнение), 261

Результат функции, 120 принадлежащий к динамическому типу, 120

Рекурсивные операции, 126 Рекурсивные процедуры, 116 Рекурсивные функции, 119 Решение системы линейных уравнений, 193

Ряд Тейлора, 202

Семантические атрибуты в синтаксических диаграммах, 270

Символы, высокоточных выражений, 84 конца строки, 64, 102, 143, 145 основные, 45 подчеркивания (_), 46 специальные, 45

Символьные выражения, 82 Симметрия, 216

Симметрия матриц (упражнение), 216 Синтаксис, 43

полное описание, 269

представление в руководстве по языку, 43

Синтаксические диаграммы, 269 использование, 271 указатель, 294

Синтаксические переменные, 44, 269 Система линейных уравнений, 193 Скалярное произведение, оптимальное, 35 точное, 91

Скалярное произведение (упражнение), 205

Скобки, 73

След произведения матриц (упражнение), 250

Сложение без ошибок округления, 85

Совместимость, 69

по присваиванию, 69, 70, 116, 130, 134, 135

расширение, 70 строк, 72 типов, 69, 116 типов массивов, 70

Совмещение, 39, 128 вызов, 130 нескольких подпрограмм, 130 операции присваивания, 134, 300 операций, 124, 128, 134 правила, 129 процедур, 128

процедур read, write, 104, 131 функций, 128

Сокращения семантических атрибутов, 270

Сопряженное число, 158

Составные операторы, 107

Специальные символы, 45

Списки, 44

Списки товаров (упражнение), 220

Список полей, 59

Сравнение величин типа dotprecision, 82

Средняя точка интервала, 163, 236 Ссылки, 67

Стандартные выражения, 73

Стандартные типы, 47, 49

Стандартные файлы input, 101 output, 101

Строки

выражения, 89 использование, 42

Строки символов, 58 динамические, 58 Структурированные операторы, 101 Структурированные типы, 53 Структурная эквивалентность, 71 Суммирование степенного ряда (упражнение), 202

Схема работы с динамическими массивами, 148

Схема совместимости массивов, 115

Текстовые файлы, 64 Терминальные символы, 269 Тест на представимость (упражнение), 201 Типы boolean, 50 char, 50 cimatrix, 66, 185 cinterval, 66, 185 civector, 66, 185 cmatrix, 66, 175 complex, 65, 157 cvector, 66, 175 dotprecision, 43, 52, 90 imatrix, 66, 180 integer, 49 interval, 65, 160 ivector, 66, 180 real, 49, 51 rmatrix, 66, 171 rvector, 66, 171 string, 139 string (динамический), 58 string (статический), 58 text, 64 арифметические, 64 безымянный, 49, 55, 70 диапазонные, 51 записи, 59 иерархия, 153 индексов, 53 компонент, 53, 62 множества, 61 перечислимые, 50 простые, 49 результата, произвольные, 38, 119

стандартные, 47, 49

структурированные, 53 указателя, 67 файла, 62 Точное

векторно-матричное произведение, 93 представление, 201 произведение матриц, 95 скалярное произведение, 91 Точность

максимальная, 32, 34, 80, 151

предопределенных функций, 156 Точные выражения, 84, 92 Транспонирование матриц, симметричные матрицы (упражнение), 216 Транспонированные матрицы, 174, 179, 184, 191

Тригонометрическое представление комплексного числа, 158

Указатели

выражений, 87, 90

высокоточных выражений, 323 зарезервированных слов, 295 операций, 297 предопределенных идентификаторов, 296

предопределенных процедур, 317 предопределенных функций, 301 синтаксических диаграмм, 294 тип, 67

функций преобразования, 315 Указуемые переменные, 67 Указуемый тип, 67 Улучшенная компьютерная арифметика, 31

Унарные операции, 74, 75 Управляющее выражение, 104, 105 Упражнения и решения, 200

Влияние погрешностей округления, 204

Вычисление полиномов, 265

Вычисления с интервальными матрицами, 238

Деление комплексных чисел, 226

Дифференциальная арифметика, 240

Измерение времени, 245

Интервальное вычисление полинома, 235

Интервальный метод Ньютона, 257

Калькулятор для полиномов, 252 Комплексные функции, 208 Матрицы Бутройда-Деккера, 207 Метод Ньютона с автоматическим дифференцированием, 243 Метод Рунге-Кутты, 258 Метод итераций, 246 Мост для измерения переменного тока, 231 Оптическая линза, 233 Параллельность и пересечение прямых, 214

Площадь поверхности параллелепипеда, 211 Представление комплексных чисел в полярной системе координат, 223

Расписание движения поезда, 218

Расчет электрической цепи, 227 Рациональная арифметика, 261 Скалярное произведение, 205 След произведения матриц, 250 Списки товаров, 220 Суммирование степенного ряда, 202

Тест на представимость, 201 Транспонирование матриц, симметричные матрицы, 216

Условные операторы, 108

Файлы, 62, 101 открытие, 102 Фактические параметры, 106, 116 Формальные параметры, 106, 115 Формат параметр, 105, 132 спецификации, 104, 131 Функции, 114, 118, 301 abs, 76, 77, 159, 163, 169, 314 arccos, 80, 159, 163, 169, 314 arccot, 80, 159, 163, 169, 314 arcosh, 80, 159, 163, 169, 314 arcoth, 80, 159, 163, 169, 314 arcsin, 80, 159, 163, 169, 314 arctan2, 80, 159, 163, 169, 315 arctan, 77, 159, 163, 169, 314 arg, 159, 169, 302 arsinh, 80, 159, 163, 169, 314 artanli, 80, 159, 163, 169, 314 blow, 164, 169, 184, 191, 302 cat, 159 chr, 82, 302 compl, 158, 168, 177, 178, 189, 315

comp, 80, 303

conj, 159, 169, 179, 191, 303 cosh, 80, 159, 163, 169, 314

cos, 77, 159, 163, 169, 314 coth, 80, 159, 163, 169, 314

cot, 80, 163, 169, 314 diam, 164, 169, 184, 191, 303 eof, 63, 81, 304

eoln, 64, 81, 304 explO, 80, 158, 163, 169, 314 exp2, 80, 158, 163, 169, 314 expo, 76, 80, 304 exp, 77, 159, 163, 169, 314 herm, 179, 191, 305 id, 174, 179, 184, 191, 305 image, 140, 305 im, 158, 168, 177, 178, 189, 316 inf, 162, 168, 182, 183, 189, 316 intval, 162, 168, 182, 183, 189, 316

ival, 76, 141, 306 Ibound, 56, 76, 81-83, 307 lb, 76, 81-83, 307 length, 140, 307

In, 77, 159, 163, 169, 314 loc, 76, 308 loglO, 80, 158, 163, 169, 314 log2, 80, 158, 163, 169, 314 mant, 80, 308 maxlength, 141, 308 mid, 163, 169, 184, 191, 308 null, 174, 179, 184, 191, 309 odd, 81, 309 ord, 76, 310 pos, 141, 310 pred, 76, 79, 81-83, 310

re, 158, 168, 177, 178, 189, 317 round, 76, 310 rval, 80, 141, 310 sign, 76, 82, 311 sinh, 80, 159, 163, 169, 314 sin, 77, 159, 163, 169, 314 sqrt, 77, 159, 163, 169, 314 sqr, 76, 77, 159, 163, 169, 314 substring, 140, 312 succ, 76, 79, 81-83, 312 sup, 162, 168, 182, 183, 189, 317 tanh, 80, 159, 163, 169, 314 tan, 80, 159, 163, 169, 314 transp, 174, 179, 184, 191, 312 trunc, 76, 313 ubound, 56, 76, 81—83, 313 ub, 76, 81-83, 313 vnull, 174, 313 вызов, 119

как формальные параметры, 120 предопределенные, 120—122 преобразования, 157, 162, 167, 177, 178, 182, 183, 188, 189, 315

преобразования типа, 88 рекурсивные, 119 с произвольным типом результата, 119 совмещение, 128 тип, 119 указатель, 301

Функции преобразования, 315 cimatrix, 189 cinterval, 167 civector, 188 cmatrix, 178 complex, 157 c vector, 177 imatrix, 183 interval, 162 i vector, 182 указатель, 315

Целочисленные выражения, 75 Цикл, пустой, 111

система, 78

Числа комплексные, 65

Чтение из файла, 63

Шестнадцатеричные константы, 51

Шрифтовые выделения, 29

Эквивалентность логическая, 81

Экспорт объектов, 136, 137

Элементы языка, 44

Эпсилон-расширение, 163

Эрмитова матрица, 179, 191

Числа с плавающей точкой, нормализованные, 78 операции, 77, 78