Файл: А. Б. Шнейвайс основы программирования.pdf

которая должна должна обрабатывать массу файлов, каждый из кото- рых содержит разное число строк (по шесть параметров в строке).
Пусть файл inp1 является одним из них.
1 10.123 10.321
.false.
(54.567,
-801.765)
M
2 20.123 20.321
.true.
(64.567,
-901.765)
A
3.
30.123 30.321
.true.
(74.567,
-701.765)
B
4 40.123 40.321
al
(84.567,
-601.765)
C
5 20 50.321
f
(64.567,
-901.765)
D
При этом известно, что среди данных могут быть сбойные значения.
Обработка строки, введённой безошибочно, осуществляется внутренней процедурой work. Программа test_iostat_1 вводит строки поочерёд- но, анализирует их на предмет наличия ошибок, обрабатывает коррект- ные строки, выводит номера некорректных и подсчитывает число всех введённых строк. Нас не должны смущать две звёздочки в операторе read — помним про операции перенаправления.
Файл с результатами обработки inp1:
n a
b l
Re(c)
Im(c)
q ier
1 10.123 10.321
F
54.567
-801.765
M
0 2
20.123 20.321
T
64.567
-901.765
A
0
Ошибка в строке под номером ... (k)=
3
Ошибка в строке под номером ... (k)=
4 5
20.000 50.321
F
64.567
-901.765
D
0
Число корректных строк ........ (m)=
3
Число вводимых строк k=
5 384

13.6
Спецификаторы перехода err=l и end=l
Спецификаторы используется только в ключевой форме.
Спецификатор err=l — спецификатор перехода по ошибке.
Спецификатор err=l — спецификатор перехода по признаку оконча- ния фйайла.
l — метка оператора, которому в соответствующем случае следует передать управление.
В качестве примера приведём программу test_iostat_2, которая де- лает то же самое, что и test_iostat_1, но используя при этом вместо iostat упомянутые спецификаторы перехода err и end.
program test_iostat_2; implicit none; integer k, m, n;
real a, b; logical l; complex c; character(1) q k=0; m=0
write(*,’(1x,"
n",7x,"a",9x,"b",6x,"l",5x,&
&
"Re(c)",7x,"Im(c)",4x,"q")’)
do k=k+1
read(*,*,err=10,end=77) n, a, b, l, c, q; m=m+1; call work cycle
77
write(*,*) ’ Число корректных строк ........ (m)=’,m; exit
10
write(*,*) ’ Ошибка в строке под номером ... (k)=’,k enddo k=k-1
write(*,*) ’ Число вводимых строк k=’,k stop 0
contains subroutine work write(*,’(i4,f10.3,f10.3,l5,2(f10.3,3x),a)’) n, a, b, l, c, q end subroutine work end
Результат пропуска программы test_iostat_2:
n a
b l
Re(c)
Im(c)
q
1 10.123 10.321
F
54.567
-801.765
M
2 20.123 20.321
T
64.567
-901.765
A
Ошибка в строке под номером ... (k)=
3
Ошибка в строке под номером ... (k)=
4 5
20.000 50.321
F
64.567
-901.765
D
Число корректных строк ........ (m)=
3
Число вводимых строк k=
5 385

13.7
Спецификатор advance=e продвижения по файлу
Спецификатор advance используется только в ключевой форме.
e справа от advance=e (advance — продвигаться) — одно из двух скалярных значений символьного типа ’yes’ или ’no’, которые при ис- пользовании форматного ввода-вывода задают один из двух способов подвижки указателя файла после чтения-записи данного:
• yes — к началу очередной записи (вне зависимости от того, сколь- ко данных из текущей при однократном вызове оператора ввода- вывода было прочитано-записано);
• no — к началу очередного данного текущей записи.
При форматном вводе-выводе по умолчанию полагается advance=’yes’.
Другими словами, если имеется файл, состоящий из ряда записей, каж- дая из которых содержит какие-то числа, то при вызове read читающий элемент после чтения из текущей записи всегда нацеливается на чте- ние следующей записи. Подчеркнём ещё раз — не на чтение очередно- го данного текущей записи, а, именно, на чтение начального данного следующей.
Если же при вызове оператора read спецификатору advance уста- новлено значение ’no’, то читающий элемент после чтения какого-либо данного текущей записи будет нацелен на чтение следующего дан- ного этой же текущей записи.
Обратимся к примеру. Пусть файл input содержит пять записей, при- чём в каждой по десять чисел типа integer, записанных по формату
10i5:
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 386

program test_advance; implicit none; integer i, j, k, a character(3) q(2) /’yes’,’no ’/
open (10,file=’input’)
do j=1,2
write(*,’(" advance=",a3,3x," Номер ",3x,"Читаемое по "/&
&
,14x,"значения",3x," I4 значение")’) q(j)
do i=1,5
if (j==2) then; k=i; else; k=10*(i-1)+1; endif read(10,’(i5)’,advance=q(j)) a;
write(*,*) ’
’,k,’ ’, a enddo rewind(10)
enddo stop 0
end
Программа test_advance выводит результаты чтения файла input сна- чала в режиме advance=’yes’, а затем (после переустановки указателя файла на его начало посредством оператора rewind(10)) — в режиме advance=’no’.
advance=yes
!
advance=no
=========================!==========================
Номер
Читаемое по
!
Номер
Читаемое по значения
I4 значение ! значения
I4 значение
1 101
!
1 101 11 111
!
2 102 21 121
!
3 103 31 131
!
4 104 41 141
!
5 105
Режим advance=’no’ выгоден, например, когда данные читаются из файла, содержимое которого — огромное количество однотипных чисел в одной длинной записи, которую накладно запоминать целиком в опе- ративной памяти (если вообще возможно). Аналогично, режим выгоден и при моделировании соответствующего файла вывода.
387

13.8
Спецификаторы eor=l и size=k для режима advance=’no’
• Спецификатор eor=l служит для организации перехода по оконча- нию записи.
l справа от знака равенства в eor=l есть метка оператора, которому передаётся управление при обнаружении окончания записи (eor —
End Of Record).
• Спецификатор size=k служит для подсчёта k количества позиций отводимых под данное, которое читается или выводится.
• Оба спецификатора используются только в режиме advance=’no’.
program test_advance_1; implicit none; integer i, j, k, ier, a open (10,file=’input’); open (20,file=’result1’,status=’replace’)
write(*,’(11x,"j",11x,"i",10x,"ier",9x,"a",12x,"k")’)
j=1; i=0;
do;
i=i+1
read (10,’(i5)’,advance=’no’,eor=3, size=k,iostat=ier) a;
if (ier<0) exit if (ier >0) then; write(*,’(a,i5,a)’) ’error in’, j,’-st line’
write(20,’(a1)’,advance=’no’) transfer(10_1,’a’);
j=j+1
endif if (ier==0) then; write(*,*) j,i,ier,a, k write(20,’(i4)’,advance=’no’) a endif cycle
3 continue; write(20,’(a1)’,advance=’no’) transfer(10_1,’a’); j=j+1
write(*,’(11x,"j",11x,"i",10x,"ier",9x,"a",12x,"k")’)
enddo write(*,’(31x,i5/a,i5,a)’) ier,’Обработано ’, i-2,’ чисел’; close(20)
end
Программа test_advance_1 демонстрирует пример работы с фай- лом input, каждая из записей (строк) которого содержит некоторое (воз- можно неодинаковое) количество чисел.
101 102 103 111 112 113 114 115 116 117 121 122 123 124 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
Запись каждой строки завершалась нажатием клавиши enter, что по- мещало в качестве последнего символа строки невидимый символ, соот- ветствующий ASCII-коду равному 10 (перевод строки).
388

Программа работает с тремя файлами:
• input, из которого оператором read в режиме advance=’no’ по формату i5 через устройство unit=10 происходит чтение чисел;
• result1, в который оператором write в режиме advance=’no’ через устройство unit=20 по формату i4 происходит перезапись чисел,
вводимых из input;
• result, в который операторами write(*,’(11x,"j 11x,"i 10x,"ier 9x,"a 12x,"k")’)
write(*,’(31x,i5/a,i5,a)’) ier,’Обработано ’, i-2,’ чисел’
через стандартное устройство вывода осуществляется построчный вывод
1. j — номера записи, в которой читаемое данное находится;
2. i — сквозного (по всем записям) номера данного;
3. ier — кода ошибки чтения текущего данного по спецификатору iostat=ier при чтении исходного файла input;
4. a — самого читаемого данного;
5. k — количества символов, из которых данное состоит.
Перенаправление стандартного вывода в файл result осуществля- ется посредством операции > при запуске исполнимого файла.
Как только ключ eor обнаруживает при чтении признак окончания текущей записи файла input программа
• передаёт управление оператору, помеченному меткой 3;
• записывает через устройство unit=20 в файл result1 невидимый символ, соответствующий коду перевода строки;
• выводит через стандартное устройство вывода фразу о завершении текущей строки; вычисляет номер следующей и возвращается к пер- вому оператору тела цикла для возможного чтения числа из очеред- ной записи файла input.
389

Вывод программы в файлы result1 и result.
101 102 103 111 112 113 114 115 116 117 121 122 123 124 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
j i
ier a
k
1 1
0 101 5
1 2
0 102 5
1 3
0 103 5
j i
ier a
k
2 5
0 111 5
2 6
0 112 5
2 7
0 113 5
2 8
0 114 5
2 9
0 115 5
2 10 0
116 5
2 11 0
117 5
j i
ier a
k
3 13 0
121 5
3 14 0
122 5
3 15 0
123 5
3 16 0
124 5
j i
ier a
k
4 18 0
131 5
4 19 0
132 5
4 20 0
133 5
4 21 0
134 5
4 22 0
135 5
4 23 0
136 5
4 24 0
137 5
4 25 0
138 5
4 26 0
139 5
4 27 0
140 5
j i
ier a
k
5 29 0
141 5
5 30 0
142 5
5 31 0
143 5
5 32 0
144 5
5 33 0
145 5
5 34 0
146 5
5 35 0
147 5
5 36 0
148 5
j i
ier a
k
-1
Обработано
36 чисел
390

14
Приложение V. Простые поэлементные функции
Напоминание. Поэлементными называются функции, которые мо- гут в качестве своего аргумента использовать как скаляр, так и массив.
В последнем случае функция применяется к каждому элементу массива.
К простым числовым функциям отнесём:
1. abs(a) — абсолютное значение аргумента a.
2. aimag(z) — мнимая часть комплексного аргумента z.
3. conjg(z) — сопряжённое комплексному аргументу z.
4. aint(a [, kind]) — усечение аргумента a до целого числа.
5. anint(a [,kind]) — ближайшее к вещественному a целое число в форме вещественного.
6. nint(a [,kind]) — ЦЕЛОЕ, ближайшее к вещественному аргументу.
7. ceiling(a [,kind]) — наименьшее целое большее или равное аргу- менту.
8. floor(a [,kind]) — наибольшее целое меньшее или равное аргументу.
9. dim(x,y) — разность x-y, если она положительна; иначе нуль.
10. dprod(x,y) — произведение вещественных аргументов
11. max(a1, a2 [, a3, ...]) — максимальное значение
12. min(a1, a2 [, a3, ...]) — минимальное значение
13. mod(a,p) — остаток от деления a на p.
14. modulo(a,p) — модифицированный остаток от деления a на p, ко- гда за результат деления принимается наибольшее целое меньшее или равное аргументу.
15. sign(a,b) — абсолютное значение a со знаком b.
391

14.1
Примеры работы с функцией abs program tsabs; implicit none integer
, parameter :: i=-17; real(4), parameter :: a=-17.3
real(8)
, parameter :: abad=-17.3
real(8)
, parameter :: aa=-17.3_8
! или -17.3d0
complex(4), parameter ::
c=(4.1,-3.1)
complex(8), parameter :: cbad=(4.1,-3.1)
complex(8), parameter ::
cc=(4.1d0,-3.1d0)
! или 4.1_8, -3.1_8
integer(2), parameter :: ia(4)=(/-3,-4,-5,6/)
write(*,*) ’ Функция abs(x): абсолютное значение аргумента.’
write(*,*) ’integer i ==>
abs(i)=’,abs(i)
write(*,*) ’real(4)
a ==>
abs(a)=’,abs(a)
write(*,*) ’real(8)
abad ==> abs(abad)=’,abs(abad)
write(*,*) ’real(8)
aa ==>
abs(aa)=’,abs(aa)
write(*,*) ’complex(4)
c ==>
abs(c)=’,abs(c)
write(*,*) ’complex(8) cbad ==> abs(cbad)=’,abs(cbad)
write(*,*) ’complex(8)
cc ==>
abs(cc)=’,abs(cc)
write(*,*) ’integer(2) ia(4)==>
abs(ia)=’,abs(ia)
end program tsabs
Функция abs(x): абсолютное значение аргумента.
integer i ==>
abs(i)=
17
real(4)
a ==>
abs(a)=
17.30000
real(8)
abad ==> abs(abad)=
17.2999992370605
real(8)
aa ==>
abs(aa)=
17.3000000000000
complex(4)
c ==>
abs(c)=
5.140039
complex(8) cbad ==> abs(cbad)=
5.14003877677095
complex(8)
cc ==>
abs(cc)=
5.14003891035856
integer(2) ia(4)==>
abs(ia)=
3 4
5 6
• Обратите внимание, что, если при задании именованной константы
(или переменной) типа REAL(8) её числовое значение будет запи- сано в форме F (обычном виде с фиксированной запятой, например
4.1), то определяемый 8-байтовый объект будет иметь лишь 7-8 вер- ных десятичных цифр, а не 15-16, как хотелось бы.
Форма F определяет по умолчанию число одинарной точности.
Поэтому 4.1 вместе cо своей погрешностью округления, соответ- ствующей одинарной точности, будет лишь по форме преобразова- но к виду удвоенной (т.е. отведётся большее число бит на порядок и мантиссу числа, добавив к имеющейся погрешности типа real(4)
ещё и погрешность типа real(8).
392

14.2
Примеры работы с функцией aimag program ts_aimag; implicit none complex(4),parameter ::
c=(4.1,-3.1)
complex(8),parameter :: cbad=(4.1,-3.1)
complex(8),parameter ::
cc=(4.1d0,-3.1d0)
complex(4),parameter :: car(3)=(/(1.2,-0.2),(1.3,0.3),(1.4,0.4)/)
write(*,*) ’ Функция aimag(z): мнимая часть комплексного числа’
write(*,*) ’complex(4)
c ==>
aimag(c)=’,aimag(c)
write(*,*) ’complex(8)
cbad ==> aimag(cbad)=’,aimag(cbad)
write(*,*) ’complex(8)
cc ==>
aimag(cc)=’,aimag(cc)
write(*,*) ’complex(4) car(3)==>
aimag(car)=’,aimag(car)
end program ts_aimag
Функция aimag(z): мнимая часть комплексного числа complex(4)
c ==>
aimag(c)=
-3.100000
complex(8)
cbad ==> aimag(cbad)=
-3.09999990463257
complex(8)
cc ==>
aimag(cc)=
-3.10000000000000
complex(4) car(3)==>
aimag(car)= -0.2000000
-0.3000000
-0.4000000
Результат пропуска после gfortran -fdefault-real-8 ts_aimag.f:
Функция aimag(z): мнимая часть комплексного числа complex(4)
c ==>
aimag(c)=
-3.100000
complex(8)
cbad ==> aimag(cbad)=
-3.10000000000000
complex(8)
cc ==>
aimag(cc)=
-3.10000000000000
complex(4) car(3)==>
aimag(car)= -0.2000000
-0.3000000
-0.4000000
У ФОРТРАН-компиляторов разных фирм наименования опций мо- гут различаться. Поэтому, спокойнее использовать ФОРТРАН-средства,
управляющие ситуацией. Например, использовать для описания пере- менных операторы:
integer, parameter :: mp=4; real(mp) a, b, c; a=1.6_mp
Если же потребуется перевод многофайлового проекта на ячейки иной разрядности, то достаточно будет изменение константы mp осуществить лишь в модуле module my_prec implicit none integer, parameter :: mp=4
! 8, 10, 16
end module my_prec который подсоединяется к нужным программным единицам оператором use my_prec.
393

14.3
Примеры работы с функцией conjg program ts_conjg; implicit none complex(4),parameter ::
c=(4.1,-3.1)
complex(8),parameter ::
cbad=(4.1,-3.1)
complex(8),parameter ::
cc=(4.1d0,-3.1d0)
complex(4),parameter :: car(3)=(/(1.2,-0.2),(1.3,0.3),(1.4,0.4)/)
complex(4) v(3)
integer i write(*,*) ’ Функция conjg(z): сопряжённое комплексному z’
write(*,’(a,2e17.8)’)
’
c ==> conjg(c)=’,
conjg( c
)
write(*,’(a/(2e25.17))’) ’cbad ==> conjg(cbad)=’, conjg(cbad)
write(*,’(a/(2e25.17))’) ’
cc ==>
conjg(cc)=’, conjg( cc )
v=conjg(car)
write(*,’(a/(i3,2e17.8))’) ’complex(4) car(3)==>
v=conjg(car)=’,
>
(i,v(i),i=1,3)
v(1)=(5,6)
write(*,’(a/2e17.8))’) ’ conjg( v(1))=’,conjg( v(1))
write(*,’(a/2e17.8))’) ’ conjg((5,6))=’,conjg((5,6))
end program ts_conjg
Функция conjg(z): сопряжённое комплексному z c ==> conjg(c)=
0.40999999E+01 0.30999999E+01
cbad ==> conjg(cbad)=
0.40999999046325684E+01 0.30999999046325684E+01
cc ==>
conjg(cc)=
0.40999999999999996E+01 0.31000000000000001E+01
complex(4) car(3)==>
v=conjg(car)=
1 0.12000000E+01 0.20000000E+00 2
0.13000000E+01
-0.30000001E+00 3
0.14000000E+01
-0.40000001E+00
conjg( v(1))=
0.50000000E+01
-0.60000000E+01
conjg((5,6))=
0.50000000E+01
-0.60000000E+01 394

14.4
Примеры работы с функцией aint program ts_aint implicit none real(4), parameter ::
a=4.1
real(8), parameter ::
abad=4.1
real(8), parameter ::
aa=4.1_8
real(10), parameter ::
b=-5.9
write(*,*) ’ Функция aint(a [,kind]): усечение до целого числа’
write(*,*) ’ real(4)
a ==>
aint(a)=’,aint(a)
write(*,*) ’ real(8) abad ==>
aint(abad)=’,aint(abad)
write(*,*) ’ real(8)
aa ==>
aint(aa)=’,aint(aa)
write(*,*) ’real(10)
b ==>
aint(b)=’, aint(b)
write(*,*) ’real(8)
aa ==> aint(aa,kind=4)=’, aint(aa,kind=4)
write(*,*) ’real(8)
aa ==>
aint(aa,4)=’, aint(aa,4)
write(*,*) ’real(4)
aa ==>
aint(aa,8)=’, aint(aa,8)
write(*,*) ’real(4)
aa ==> aint(a=aa,kind=8)=’,aint(a=aa,kind=8)
write(*,*) ’real(4)
aa ==> aint(kind=8,a=aa)=’,aint(kind=8,a=aa)
end program ts_aint
Функция aint(a [,kind]): усечение до целого числа real(4)
a ==>
aint(a)=
4.0000000
real(8) abad ==>
aint(abad)=
4.0000000000000000
real(8)
aa ==>
aint(aa)=
4.0000000000000000
real(10)
b ==>
aint(b)=
-5.0000000000000000000
real(8)
aa ==> aint(aa,kind=4)=
4.0000000
real(8)
aa ==>
aint(aa,4)=
4.0000000
real(4)
aa ==>
aint(aa,8)=
4.0000000000000000
real(4)
aa ==> aint(a=aa,kind=8)=
4.0000000000000000
real(4)
aa ==> aint(kind=8,a=aa)=
4.0000000000000000
• Обратите внимание на то, что функция aint без второго параметра
(необязательного, если он не нужен) получает результат того же типа, что и аргумент, т.е. соответствующего вещественного типа, о чём можно судить по количеству нулей мантиссы.
• aint работает с аргументами исключительно вещественного типа.
Типы integer и complex приводят к сообщению об ошибке.
• aint производит именно усечение числа, путём отбрасывания его дробной части.
• Помним, что при вызове любой функции любой её аргумент можно задать как в ключевой форме (например,aint(aa,kind=4)), так и позиционной (например,aint(aa,4)).
395

14.5
Примеры работы с функцией anint program ts_anint implicit none real(4), parameter ::
a=4.1
real(8), parameter ::
b=4.9
real(8), parameter ::
c=-4.1_8
real(10), parameter ::
d=-5.9_10
write(*,*) ’ Функция anint(a [,kind]): ближайшее к вещественному’
write(*,*) ’
целое число в форме вещественного’
write(*,*) ’ real(4)
a=4.1
anint(a)=’,anint(a)
write(*,*) ’ real(8)
b=4.9
anint(b)=’,anint(b)
write(*,*) ’ real(8)
c=-4.1_8
anint(c)=’,anint(c)
write(*,*) ’real(10)
d=-5.9_10 anint(d)=’,anint(d)
end program ts_anint
Функция anint(a [,kind]): ближайшее к вещественному целое число в форме вещесьвенного real(4)
a=4.1
anint(a)=
4.0000000
real(8)
b=4.9
anint(b)=
5.0000000000000000
real(8)
c=-4.1_8
anint(c)=
-4.0000000000000000
real(10)
d=-5.9_10 anint(d)=
-6.0000000000000000000 14.6
Примеры работы с функцией nint program ts_nint implicit none real(4), parameter ::
a=4.1
real(8), parameter ::
b=4.9
real(8), parameter ::
c=-4.1_8
real(10), parameter ::
d=-5.9_10
write(*,*) ’ Функция nint(a [,kind]): ЦЕЛОЕ, ближайшее к ’,
>
’ вещественному’
write(*,*) ’ real(4)
a=4.1
nint(a)=’,nint(a)
write(*,*) ’ real(8)
b=4.9
nint(b)=’,nint(b)
write(*,*) ’ real(8)
c=-4.1_8
nint(c)=’,nint(c)
write(*,*) ’real(10)
d=-5.9_10 nint(d)=’,nint(d)
end program ts_nint
Функция nint(a [,kind]): ЦЕЛОЕ, ближайшее к вещественному real(4)
a=4.1
nint(a)=
4
real(8)
b=4.9
nint(b)=
5
real(8)
c=-4.1_8
nint(c)=
-4
real(10)
d=-5.9_10 nint(d)=
-6 396

14.7
Примеры работы с функцией ceiling program ts_ceiling implicit none real(4), parameter ::
a=4.1
real(8), parameter ::
b=4.9
real(8), parameter ::
c=-4.1_8
real(10), parameter ::
d=-5.9_10
write(*,*) ’ Функция ceiling(a [,kind]): наименьшее ЦЕЛОЕ большее’
write(*,*) ’
или равное аргументу’
write(*,*) ’
ceiling(4.0)=’,ceiling(4.0)
write(*,*) ’ real(4) a=4.1
ceiling(a)=’,ceiling(a)
write(*,*) ’ real(8) b=4.9
ceiling(b)=’,ceiling(b)
write(*,*) ’ real(8) c=-4.1_8
ceiling(c)=’,ceiling(c)
write(*,*) ’real(10) d=-5.9_10 ceiling(d)=’,ceiling(d)
end program ts_ceiling
Функция ceiling(a [,kind]): наименьшее ЦЕЛОЕ большее или равное аргументу ceiling(4.0)=
4
real(4) a=4.1
ceiling(a)=
5
real(8) b=4.9
ceiling(b)=
5
real(8) c=-4.1_8
ceiling(c)=
-4
real(10) d=-5.9_10 ceiling(d)=
-5 14.8
Примеры работы с функцией floor program ts_floor implicit none real(4), parameter ::
a=4.1
real(8), parameter ::
b=4.9
real(8), parameter ::
c=-4.1_8
real(10), parameter ::
d=-5.9_10
write(*,*) ’ Функция floor(a [,kind]): наибольшее ЦЕЛОЕ меньшее’
write(*,*) ’
или равное аргументу’
write(*,*) ’
floor(4.0)=’,floor(4.0)
write(*,*) ’ real(4) a=4.1
floor(a)=’,floor(a)
write(*,*) ’ real(8) b=4.9
floor(b)=’,floor(b)
write(*,*) ’ real(8) c=-4.1_8
floor(c)=’,floor(c)
write(*,*) ’real(10) d=-5.9_10 floor(d)=’,floor(d)
end program ts_floor
Функция floor(a [,kind]): наибольшее ЦЕЛОЕ меньшее или равное аргументу floor(4.0)=
4
real(4) a=4.1
floor(a)=
4
real(8) b=4.9
floor(b)=
4
real(8) c=-4.1_8
floor(c)=
-5
real(10) d=-5.9_10 floor(d)=
-6 397

14.9
Примеры работы с функцией dim program ts_dim implicit none real(4)
a,
b,
c,
d complex(4) u, v write(*,*) ’ Функция dim(x,y): разность x-y, если она’
write(*,*) ’
ПОЛОЖИТЕЛЬНА;
иначе нуль’
a=4.3; b=3.3;
write(*,’("dim(a,b)=",e15.7)’) dim(a,b)
c=3.3; d=4.3;
write(*,’("dim(c,d)=",e15.7)’) dim(c,d)
write(*,’("dim(4,1)=",i5)’) dim(4,1)
write(*,’("dim(1,4)=",i5)’) dim(1,4)
end program ts_dim
Функция dim(x,y): разность x-y, если она
ПОЛОЖИТЕЛЬНА;
иначе нуль dim(a,b)=
0.1000000E+01
dim(c,d)=
0.0000000E+00
dim(4,1)=
3
dim(1,4)=
0 398