Возможности языка Fortran 95

Это обзор возможностей языка Fortran 95. Включены дополнительные возможности TR-15581:Enhanced Data Type Facilities, которые были реализованы повсеместно. Старые возможности, которые были заменены новыми, не описаны — немногие из этих исторических возможностей используются в современных программах, хотя большинство из них были сохранены в языке для поддержания обратной совместимости . Дополнительные возможности последующих стандартов, вплоть до Fortran 2023, описаны в стандартном документе Fortran 2023, ISO/IEC 1539-1:2023. Многие из его новых возможностей все еще реализуются в компиляторах. ^[1]

Fortran нечувствителен к регистру . В этой статье принято соглашение о написании ключевых слов Fortran в верхнем регистре, а всех остальных имен в нижнем; за исключением, в качестве контраста, описаний ввода/вывода (Передача данных и Операции с внешними файлами).

Основным компонентом языка Фортран является его набор символов . Его членами являются

• буквы A ... Z и a ... z (которые эквивалентны вне контекста символа)
• цифры 0 ... 9
• подчеркивание _
• специальные символы=  : + blank - * / ( ) [ ] , . $ ' ! "  % &  ; < >  ?

Токены , имеющие синтаксическое значение для компилятора, строятся из этих компонентов. Существует шесть классов токенов:

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

FUNCTION string_concat ( s1 , s2 ) ! Это комментарий TYPE ( string ), INTENT ( IN ) :: s1 , s2 TYPE ( string ) string_concat string_concat % string_data = s1 % string_data ( 1 : s1 % length ) // & s2 % string_data ( 1 : s2 % length ) ! Это продолжение string_concat % length = s1 % length + s2 % length END FUNCTION string_concat                       

Обратите внимание на завершающие комментарии и завершающий знак продолжения. Может быть 39 строк продолжения и 132 символа в каждой строке. Пробелы имеют значение. Если токен или константа символа разделены на две строки:

 ... начало_имени ... 'очень длинная  & & строка '    

&Также требуется наличие лидирующей части на продолжении линии.

Fortran имеет пять внутренних типов данных : INTEGER, REAL, COMPLEX, LOGICALи CHARACTER. Каждый из этих типов может быть дополнительно охарактеризован видом . Вид, по сути, определяет внутреннее представление типа: для трех числовых типов он определяет точность и диапазон, а для двух других — специфику представления хранения. Таким образом, это абстрактное понятие, которое моделирует пределы представления типов данных; оно выражается как элемент набора целых чисел (например, это может быть {1, 2, 4, 8} для целых чисел, обозначающих байты хранения), но эти значения не определены Стандартом и не переносимы. Для каждого типа существует вид по умолчанию , который используется, если вид явно не указан. Для каждого внутреннего типа существует соответствующая форма литеральной константы . Числовые типы INTEGERи REALмогут быть только знаковыми (понятия знака для типа нет COMPLEX).

Целочисленные литеральные константы типа по умолчанию имеют вид

1 0 - 999 32767 + 10    

Kind может быть определен как именованная константа. Если желаемый диапазон составляет ±10 ^kind , переносимый синтаксис для определения соответствующего kind two_bytes—

ЦЕЛОЕ ЧИСЛО , ПАРАМЕТР :: two_bytes = SELECTED_INT_KIND ( 4 )     

что позволяет впоследствии определять константы вида

- 1234_два_байта + 1_два_байта 

Здесь two_bytes— параметр типа kind; это также может быть явная целочисленная литеральная константа по умолчанию, например

- 1234_2

но такое использование непереносимо.

Функция KIND возвращает значение параметра типа kind:

ВИД ( 1 ) ВИД ( 1_два_байта ) 

и RANGEфункция предоставляет фактический десятичный диапазон (поэтому пользователь должен выполнить фактическое сопоставление с байтами):

ДИАПАЗОН ( 1_два_байта )

Кроме того, в операторах DATA (инициализация) могут использоваться двоичные (B), восьмеричные (O) и шестнадцатеричные (Z) константы (часто неформально называемые «константами BOZ»):

B '01010101' O '01234567' Z '10fa'  

Существует как минимум два действительных типа — по умолчанию и один с большей точностью (он заменяет DOUBLE PRECISION). SELECTED_REAL_KINDФункции возвращают номер типа для требуемого диапазона и точности; для как минимум 9 десятичных знаков точности и диапазона от 10 ⁻⁹⁹ до 10 ⁹⁹ его можно указать как:

ЦЕЛОЕ ЧИСЛО , ПАРАМЕТР :: long = SELECTED_REAL_KIND ( 9 , 99 )      

и литералы впоследствии указаны как

1.7_длинный

Также существуют внутренние функции

ТИП ( 1.7_long ) ТОЧНОСТЬ ( 1.7_long ) ДИАПАЗОН ( 1.7_long )  

которые в свою очередь дают значение типа типа, фактическую точность (здесь не менее 9) и фактический диапазон (здесь не менее 99).

COMPLEXТип данных состоит из двух целочисленных или действительных компонентов:

( 1 , 3.7_длинный ) 

Существует только два основных значения логических констант: .TRUE.и .FALSE.. Здесь также могут быть разные виды. Логические не имеют собственных функций запроса видов, но используют виды, указанные для INTEGERs; вид по умолчанию LOGICALтакой же, как у INTEGER.

. ЛОЖЬ . . правда . _ один_байт 

и KINDфункция работает так, как и ожидалось:

ВИД (. ИСТИНА .)

Формы литеральных констант для CHARACTERтипа данных:

'Строка' "Другой" ' ''''' '   

(последнее — пустая строка). Разрешены различные типы (например, для различения строк ASCII и UNICODE ), но не поддерживаются широко компиляторами. Опять же, значение типа задается функцией KIND:

ТИП ( 'ASCII' )

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

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

INTEGER ( KIND = 2 ) :: i REAL ( KIND = long ) :: a COMPLEX :: current LOGICAL :: Pravda CHARACTER ( LEN = 20 ) :: word CHARACTER ( LEN = 2 , KIND = Kanji ) :: kanji_word             

где необязательный KINDпараметр указывает нестандартный вид, а ::нотация отделяет тип и атрибуты от имени(й) переменной(ых) и их необязательных начальных значений, что позволяет вводить полную спецификацию и инициализацию переменных в одном операторе (в предыдущих стандартах атрибуты и инициализаторы приходилось объявлять в нескольких операторах). Хотя в приведенных выше примерах это не требуется (поскольку нет дополнительных атрибутов и инициализации), большинство программистов на Fortran-90 привыкают использовать его везде.

LEN=спецификатор применим только к CHARACTERs и указывает длину строки (заменяя старую *lenформу). Явные KIND=и LEN=спецификаторы необязательны:

ХАРАКТЕР ( 2 , Кандзи ) :: kanji_word   

работает так же хорошо.

Есть еще несколько интересных особенностей характера. Так же как подстрока, как в

СИМВОЛ ( 80 ) :: строка ... = строка ( i : i ) ! подстрока      

раньше было возможно, теперь подстрока

'0123456789' ( я : я )

Также допускаются строки нулевой длины:

строка ( i : i - 1 ) ! строка нулевой длины 

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

Для производных типов данных сначала необходимо определить форму типа:

ТИП персона ПЕРСОНАЖ ( 10 ) имя РЕАЛЬНЫЙ возраст КОНЕЦ ТИП персона   

и затем можно определить переменные этого типа:

ТИП ( человек ) ты , я  

Для выбора компонентов производного типа %используется квалификатор:

ваш % возраст

Литеральные константы производных типов имеют вид TypeName(1stComponentLiteral, 2ndComponentLiteral, ...):

вы = человек ( 'Смит' , 2 3,5 )   

который известен как конструктор структур . Определения могут ссылаться на ранее определенный тип:

ТИП точка REAL x , y КОНЕЦ ТИП точка ТИП треугольник ТИП ( точка ) a , b , c КОНЕЦ ТИП треугольник      

и для переменной типа треугольник, как в

ТИП ( треугольник ) т 

каждый компонент типа pointдоступен как

т % а т % б т % в  

которые, в свою очередь, имеют конечные компоненты типа real:

т % а % х т % а % у т % б % х и т.д.   

(Обратите внимание, что %был выбран квалификатор вместо точки ( .) из-за потенциальной неоднозначности с записью оператора, например .OR.).

Если не указано иное, все переменные, начинающиеся с букв I, J, K, L, M и N, являются переменными по умолчанию INTEGERs, а все остальные — переменными по умолчанию REAL; другие типы данных должны быть явно объявлены. Это известно как неявная типизация и является наследием ранних дней FORTRAN. Эти значения по умолчанию могут быть переопределены с помощью IMPLICIT TypeName (CharacterRange)операторов, например:

НЕЯВНЫЙ КОМПЛЕКС ( Z ) НЕЯВНЫЙ ХАРАКТЕР ( A - B ) НЕЯВНЫЙ ВЕЩЕСТВЕННЫЙ ( C - H , N - Y )

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

Массивы считаются переменными сами по себе. Каждый массив характеризуется своим типом , рангом и формой (которая определяет пределы каждого измерения). Границы каждого измерения по умолчанию равны 1 и размеру , но произвольные границы могут быть явно указаны. DIMENSIONключевое слово является необязательным и считается атрибутом; если оно опущено, форма массива должна быть указана после имени переменной-массива. Например,

REAL :: a ( 10 ) INTEGER , РАЗМЕРНОСТЬ ( 0 : 100 , - 50 : 50 ) :: карта     

объявляет два массива, rank-1 и rank-2, элементы которых располагаются в порядке столбцов . Элементы, например,

а ( 1 ) а ( я * дж ) 

и являются скалярами. Индексы могут быть любым скалярным целочисленным выражением.

Разделы являются частями переменных массива и сами по себе являются массивами:

a ( i : j ) ! ранг один map ( i : j , k : l : m ) ! ранг два a ( map ( i , k : l )) ! индекс вектора a ( 3 : 2 ) ! нулевая длина      

Целые массивы и секции массивов являются объектами, имеющими значения массива. Константы, имеющие значения массива (конструкторы), доступны, заключенные в (/ ... /):

( / 1 , 2 , 3 , 4 / ) ( / ( ( / 1 , 2 , 3 / ), я = 1 , 4 ) / ) ( / ( я , я = 1 , 9 , 2 ) / ) ( / ( 0 , я = 1 , 100 ) / ) ( / ( 0,1 * я , я = 1 , 10 ) / )                                   

используя подразумеваемую нотацию цикла DO. Fortran 2003 позволяет использовать скобки: [1, 2, 3, 4]и [([1,2,3], i=1,4)]вместо первых двух примеров выше, и многие компиляторы теперь поддерживают это. Производный тип данных может, конечно, содержать компоненты массива:

ТИП триплет REAL , РАЗМЕРНОСТЬ ( 3 ) :: вершина КОНЕЦ ТИП триплет ТИП ( триплет ), РАЗМЕРНОСТЬ ( 4 ) :: t       

так что

• t(2) является скаляром (структурой)
• t(2)%vertex является компонентом массива скаляра

Переменным могут быть присвоены начальные значения, указанные в спецификации:

РЕАЛЬНЫЙ , РАЗМЕРНОСТЬ ( 3 ) :: a = ( / 0,1 , 0,2 , 0,3 / )         

и компоненту производного типа данных может быть присвоено начальное значение по умолчанию:

ТИП триплет REAL , РАЗМЕРНОСТЬ ( 3 ) :: вершина = 0.0 КОНЕЦ ТИП триплет      

Когда локальные переменные инициализируются внутри процедуры, они неявно приобретают атрибут SAVE:

РЕАЛЬНЫЙ , РАЗМЕРНОСТЬ ( 3 ) :: точка = ( / 0,0 , 1,0 , - 1,0 / )         

Это заявление эквивалентно

РЕАЛЬНЫЙ , РАЗМЕР ( 3 ), СОХРАНИТЬ :: точка = ( / 0.0 , 1.0 , - 1.0 / )          

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

Именованную константу можно указать напрямую, добавив PARAMETERатрибут и значения константы к оператору типа:

REAL , РАЗМЕРНОСТЬ ( 3 ) , ПАРАМЕТР :: поле = ( /0.,1.,2./ ) ТИП ( триплет ) , ПАРАМЕТР :: t = триплет ( ( /0.,0.,0./ ) )​​​​​​​​​​                     

Оператор DATAможет использоваться для скаляров, а также для массивов и переменных производного типа. Это также единственный способ инициализировать только части таких объектов, а также инициализировать двоичными, восьмеричными или шестнадцатеричными значениями:

ТИП ( триплет ) :: t1 , t2 ДАННЫЕ t1 / триплет ( ( / 0. , 1. , 2. / ) ) / , t2 % вершина ( 1 ) / 12 3. / ДАННЫЕ массив ( 1 : 64 ) / 64 * 0 / ДАННЫЕ i , j , k / B '01010101' , O '77' , Z 'ff' /                 

Значения, используемые в операторах DATAи PARAMETERили с этими атрибутами, являются константными выражениями, которые могут включать ссылки на: конструкторы массивов и структур, элементарные встроенные функции с целочисленными или символьными аргументами и результатами, а также шесть трансформационных функций REPEAT, SELECTED_INT_KIND, TRIM, SELECTED_REAL_KIND, RESHAPEи TRANSFER(см. Встроенные процедуры):

ЦЕЛОЕ ЧИСЛО , ПАРАМЕТР :: long = SELECTED_REAL_KIND ( 12 ), & массив ( 3 ) = ( / 1 , 2 , 3 / )             

Можно указать сведения о переменных, используя любое неконстантное, скалярное, целочисленное выражение, которое также может включать ссылки на функции запроса:

ПОДПРОГРАММА s ( b , m , c ) ИСПОЛЬЗОВАТЬ mod ! содержит a REAL , DIMENSION (:, :) :: b REAL , DIMENSION ( UBOUND ( b , 1 ) + 5 ) :: x INTEGER :: m CHARACTER ( LEN =* ) :: c CHARACTER ( LEN = m + LEN ( c )) :: cc REAL ( SELECTED_REAL_KIND ( 2 * PRECISION ( a ))) :: z                                

Доступны обычные арифметические операторы +, -, *, /, **(приведены здесь в порядке возрастания приоритета).

Скобки используются для указания порядка оценки, где это необходимо:

а * б + в ! * первый а * ( б + в ) ! + первый      

Правила для скалярных числовых выражений и присваиваний учитывают нестандартные типы. Таким образом, смешанные числовые выражения и правила присваивания включают различные параметры типа типа ожидаемым образом:

real2 = integer0 + real1    

преобразуется integer0в действительное значение того же рода, что и real1; результат имеет тот же род и преобразуется в вид real2для присваивания.

Эти функции доступны для контролируемого округления действительных чисел до целых:

• NINT: округлить до ближайшего целого числа, вернуть целочисленный результат
• ANINT: округлить до ближайшего целого числа, вернуть действительный результат
• INT: усечение (округление в сторону нуля), возврат целого результата
• AINT: усечение (округление в сторону нуля), возврат действительного результата
• CEILING: наименьшее целое значение, не меньшее аргумента (округление вверх) (Fortran-90)
• FLOOR: наибольшее целое значение, не большее аргумента (округлено в меньшую сторону) (Fortran-90)

Для скалярных реляционных операций числовых типов существует набор встроенных операторов:

< <= == /= > >=.LT. .LE. .EQ. .NE. .GT. .GE.

(формы выше являются новыми для Fortran-90, а более старые эквивалентные формы приведены ниже). Примеры выражений:

a < b . AND . i /= j ! для числовых переменных flag = a == b ! для логических переменных flags            

В случае скалярных символов и заданныхCHARACTER(8) result

это законно писать

результат ( 3 : 5 ) = результат ( 1 : 3 ) ! перекрытие разрешено результат ( 3 : 3 ) = результат ( 3 : 2 ) ! нет назначения нулевой строки      

Конкатенация выполняется оператором '//'.

результат = 'abcde' // '123' имя файла = результат // '.dat'    

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

ТИП string80 INTEGER длина CHARACTER ( 80 ) значение КОНЕЦ ТИП string80 CHARACTER :: char1 , char2 , char3 ТИП ( string80 ) :: str1 , str2 , str3         

мы можем написать

str3 = str1 // str2 ! необходимо определить операцию str3 = str1 . concat . str2 ! необходимо определить операцию char3 = char2 // char3 ! только внутренний оператор str3 = char1 ! необходимо определить присваивание            

Обратите внимание на « перегруженное » использование внутреннего символа //и именованного оператора .concat.. Разница между двумя случаями заключается в том, что для токена внутреннего оператора применяются обычные правила приоритета, тогда как для именованных операторов приоритет является наивысшим как у унарного оператора или низшим как у бинарного. В

вектор3 = матрица * вектор1 + вектор2 вектор3 = ( матрица . умножить на . вектор1 ) + вектор2           

эти два выражения эквивалентны только в том случае, если добавлены соответствующие скобки, как показано. В каждом случае в модуле должны быть определены процедуры, определяющие оператор и присваивание, а также соответствующая ассоциация оператор-процедура, как показано ниже:

ОПЕРАТОР ИНТЕРФЕЙСА ( // ) !Перегружает оператор // как вызывающий процедуру string_concat МОДУЛЬ ПРОЦЕДУРА string_concat КОНЕЦ ИНТЕРФЕЙСА  

Функция конкатенации строк — это более сложная версия той, что уже была показана в Basics. Обратите внимание, что для обработки состояния ошибки, которое возникает, когда две строки вместе превышают предустановленный предел в 80 символов, было бы безопаснее использовать подпрограмму для выполнения конкатенации (в этом случае перегрузка операторов не будет применима).

МОДУЛЬ string_type НЕЯВНЫЙ НЕТ  ТИП string80 ЦЕЛОЕ число длина СИМВОЛ ( LEN = 80 ) :: string_data КОНЕЦ ТИП string80 НАЗНАЧЕНИЕ ИНТЕРФЕЙСА ( = ) МОДУЛЬ ПРОЦЕДУРА c_to_s_assign , s_to_c_assign КОНЕЦ ИНТЕРФЕЙС ОПЕРАТОР  ИНТЕРФЕЙСА ( // ) МОДУЛЬ ПРОЦЕДУРА string_concat КОНЕЦ ИНТЕРФЕЙС  СОДЕРЖИТ ПОДПРОГРАММУ c_to_s_assign ( s , c ) ТИП ( string80 ), НАМЕРЕНИЕ ( OUT ) :: s СИМВОЛ ( LEN =* ), НАМЕРЕНИЕ ( IN ) :: c s % string_data = c s % длина = LEN ( c ) КОНЕЦ ПОДПРОГРАММА c_to_s_assign ПОДПРОГРАММА s_to_c_assign ( c , s ) ТИП ( string80 ), INTENT ( IN ) :: s CHARACTER ( LEN =* ), INTENT ( OUT ) :: c c = s % string_data ( 1 : s % length ) КОНЕЦ ПОДПРОГРАММЫ s_to_c_assign ТИП ( string80 ) ФУНКЦИЯ string_concat ( s1 , s2 ) ТИП ( string80 ), INTENT ( IN ) :: s1 , s2 ТИП ( string80 ) :: s ЦЕЛОЕ ЧИСЛО :: n1 , n2 СИМВОЛ ( 160 ) :: ctot n1 = LEN_TRIM ( s1 % string_data ) n2 = LEN_TRIM ( s2 %                                                                    string_data ) IF ( n1 + n2 <= 80 ) then s % string_data = s1 % string_data ( 1 : n1 ) // s2 % string_data ( 1 : n2 ) ELSE ! Это ошибочное состояние, которое следует обработать - сейчас просто усекаем ctot = s1 % string_data ( 1 : n1 ) // s2 % string_data ( 1 : n2 ) s % string_data = ctot ( 1 : 80 ) END IF s % length = LEN_TRIM ( s % string_data ) string_concat = s END FUNCTION string_concat END MODULE string_type                        ПРОГРАММА main USE string_type TYPE ( string80 ) :: s1 , s2 , s3 CALL c_to_s_assign ( s1 , 'Меня зовут' ) CALL c_to_s_assign ( s2 , 'Линус Торвальдс' ) s3 = s1 // s2 WRITE ( * , * ) 'Результат: ' , s3 % string_data WRITE ( * , * ) 'Длина: ' , s3 % length КОНЕЦ ПРОГРАММЫ               

Определенные операторы, подобные этим, требуются для выражений, которые также разрешены в конструкторах структур (см. Производные типы данных):

str1 = string ( 2 , char1 // char2 ) ! конструктор структуры    

В случае массивов, если они имеют одинаковую форму (согласующиеся), операции и присваивания расширяются очевидным образом, поэлементно. Например, данные объявления

REAL , РАЗМЕРНОСТЬ ( 10 , 20 ) :: a , b , c REAL , РАЗМЕРНОСТЬ ( 5 ) :: v , w ЛОГИЧЕСКИЙ флаг ( 10 , 20 )           

можно записать:

a = b ! присваивание всего массива c = a / b ! деление всего массива и присваивание c = 0. ! присваивание всего массива скалярному значению w = v + 1. ! сложение всего массива со скалярным значением w = 5 / v + a ( 1 : 5 , 5 ) ! деление массива и сложение с разделом flag = a == b ! проверка отношения всего массива и присваивание c ( 1 : 8 , 5 : 10 ) = a ( 2 : 9 , 5 : 10 ) + b ( 1 : 8 , 15 : 20 ) ! сложение и присваивание раздела массива v ( 2 : 5 ) = v ( 1 : 4 ) ! присваивание перекрывающегося раздела                                  

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

Некоторые реальные внутренние функции, которые полезны для числовых вычислений:

Это массив значений для аргументов массива (элементарные), как и все функции FORTRAN 77 (кроме LEN):

Степени, логарифмы и тригонометрические функции

Комплексные числа:

Ниже приведены данные для персонажей:

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

Простейшим условным тестом является IFутверждение:IF (a > b) x = y

Полноценная IFконструкция проиллюстрирована

ЕСЛИ ( i < 0 ) ТО  ЕСЛИ ( j < 0 ) ТО x = 0. ИНАЧЕ z = 0. КОНЕЦ ЕСЛИ ИНАЧЕ ЕСЛИ ( k < 0 ) ТО z = 1. ИНАЧЕ x = 1. КОНЕЦ ЕСЛИ                          

Эта CASEконструкция является заменой вычисляемой GOTO, но лучше структурирована и не требует использования меток операторов:

SELECT CASE ( number ) ! number of type integer CASE (: - 1 ) ! all values ​​less 0 n_sign = - 1 CASE ( 0 ) ! only 0 n_sign = 0 CASE ( 1 :) ! all values ​​more 0 n_sign = 1 END SELECT                 

Каждый CASEсписок селекторов может содержать список и/или диапазон целых чисел, символьных или логических констант, значения которых не могут перекрываться внутри или между селекторами:

ДЕЛО ( 1 , 2 , 7 , 10 : 17 , 23 )     

Доступно значение по умолчанию:

СЛУЧАЙ ПО УМОЛЧАНИЮ

Существует только одна оценка и только одно совпадение.

Упрощенная, но достаточная форма конструкции DOпроиллюстрирована следующим образом:

внешний : DO внутренний : DO i = j , k , l ! от j до k с шагом l (l необязательно) : IF (...) CYCLE : IF (...) EXIT внешний : END DO внутренний END DO внешний                  

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

Многие, но не все, простые циклы можно заменить выражениями массива и присваиваниями или новыми встроенными функциями. Например

tot = 0. DO i = m , n tot = tot + a ( i ) КОНЕЦ DO          

становится простоtot = SUM( a(m:n) )

Для обсуждения этой темы нам нужны некоторые определения. В логических терминах исполняемая программа состоит из одной основной программы и нуля или более подпрограмм (или процедур ) — они что-то делают. Подпрограммы — это либо функции , либо подпрограммы , которые являются внешними, внутренними или модульными подпрограммами. (Внешние подпрограммы — это то, что мы знали из FORTRAN 77.)

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

Пример основной (и полной) программы:

ПРОГРАММА тест ПЕЧАТЬ * , 'Привет, мир!' КОНЕЦ ПРОГРАММЫ тест   

Примером основной программы и внешней подпрограммы, образующих исполняемую программу, является

ПРОГРАММА test CALL print_message КОНЕЦ ПРОГРАММЫ test SUBROUTINE print_message ПЕЧАТЬ * , 'Привет, мир!' КОНЕЦ ПОДПРОГРАММЫ print_message    

Форма функции:

ФУНКЦИЯ имя ( arg1 , arg2 ) ! ноль или более аргументов : имя = ... : END ФУНКЦИЯ имя        

Форма ссылки функции:x = name(a, b)

Внутренняя подпрограмма содержится одна в другой (максимум на одном уровне вложенности) и обеспечивает замену функции оператора:

ПОДПРОГРАММА внешняя REAL x , y : СОДЕРЖИТ  ПОДПРОГРАММУ внутренняя REAL y y = x + 1. : КОНЕЦ ПОДПРОГРАММЫ внутренняя ! ПОДПРОГРАММА обязательна КОНЕЦ ПОДПРОГРАММЫ внешняя            

Мы говорим, что является outerхостом иinner что innerполучает доступ к сущностям в outerпосредством ассоциации с хостом (например, с x), тогда как yявляется локальной переменной для inner.

Областью действия именованной сущности является единица области действия , в данном случае outerменьше innerи inner.

Имена программных модулей и внешних процедур являются глобальными , а имена подразумеваемых переменных DO имеют область действия оператора, который их содержит.

Модули используются для упаковки

• глобальные данные (заменяют COMMON и BLOCK DATA из Fortran 77);
• определения типов (которые сами по себе являются единицей области действия);
• подпрограммы (которые, помимо прочего, заменяют использование ENTRY из Fortran 77);
• интерфейсные блоки (еще одна единица обзора, см. Интерфейсные блоки);
• перечислите группы поимённо (см. любой учебник).

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

MODULE interval_arithmetic ТИП интервал REAL нижний , верхний КОНЕЦ ТИП интервал ИНТЕРФЕЙС ОПЕРАТОР ( + ) МОДУЛЬ ПРОЦЕДУРА add_intervals КОНЕЦ ИНТЕРФЕЙС : СОДЕРЖИТ  ФУНКЦИЮ add_intervals ( a , b ) ТИП ( интервал ), НАМЕРЕНИЕ ( В ) :: a , b ТИП ( интервал ) add_intervals add_intervals % нижний = a % нижний + b % нижний add_intervals % верхний = a % верхний + b % верхний КОНЕЦ ФУНКЦИЯ add_intervals ! ФУНКЦИЯ обязательная : КОНЕЦ МОДУЛЬ interval_arithmetic                            

и простое утверждение

 ИСПОЛЬЗОВАТЬ интервальную арифметику

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

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

REAL , PUBLIC :: x , y , z ! default INTEGER , PRIVATE :: u , v , w           

и форма заявления

ОБЩЕСТВЕННЫЙ :: x , y , z , ОПЕРАТОР (. add .) ЧАСТНЫЙ :: u , v , w , ПРИСВОЕНИЕ ( = ), ОПЕРАТОР ( * )           

Форму заявления необходимо использовать для ограничения доступа операторов, а также ее можно использовать для изменения общего значения по умолчанию:

PRIVATE ! устанавливает значение по умолчанию для модуля PUBLIC :: only_this   

Для производных типов существует три возможности: тип и его компоненты являются PUBLIC, тип является PUBLIC, а его компоненты — PRIVATE (видим только тип, и можно легко изменить его данные), или все они являются PRIVATE (только для внутреннего использования в модуле):

МОДУЛЬ мой ЧАСТНЫЙ  ТИП , ОБЩИЙ :: список РЕАЛЬНЫЙ x , y ТИП ( список ), УКАЗАТЕЛЬ :: следующий КОНЕЦ ТИП список ТИП ( список ) :: дерево : КОНЕЦ МОДУЛЬ мой               

Целью оператора USEявляется получение доступа к сущностям в модуле. Он имеет опции для разрешения конфликтов имен, если импортированное имя совпадает с локальным:

ИСПОЛЬЗУЙТЕ мой , local_list => список   

или ограничить используемые сущности указанным набором:

ИСПОЛЬЗУЙТЕ мой , ТОЛЬКО : список   

Их можно комбинировать:

ИСПОЛЬЗУЙТЕ мой , ТОЛЬКО : local_list => list     

Мы можем указать цель фиктивных аргументов:

ПОДПРОГРАММА перетасовки ( ncards , карты ) ЦЕЛОЕ ЧИСЛО , НАМЕРЕНИЕ ( ВХОД ) :: ncards ЦЕЛОЕ ЧИСЛО , НАМЕРЕНИЕ ( ВЫХОД ), РАЗМЕР ( ncards ) :: карты           

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

Аргументы могут быть необязательными:

ПОДПРОГРАММА mincon ( n , f , x , upper , lower , equalities , inequalityities , convex , xstart ) REAL , OPTIONAL , DIMENSION :: upper , lower : IF ( PRESENT ( lower )) THEN ! проверка на наличие фактического аргумента :                    

позволяет нам звонить minconпо

CALL mincon ( n , f , x , верхний )    

Аргументы могут быть ключевыми словами, а не позиционными (которые идут первыми):

CALL mincon ( n , f , x , равенства = 0 , xstart = x0 )    

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

Любая ссылка на внутреннюю или модульную подпрограмму осуществляется через интерфейс, который является «явным» (то есть компилятор может видеть все детали). Ссылка на внешнюю (или фиктивную) процедуру обычно является «неявной» (компилятор предполагает детали). Однако в этом случае мы также можем предоставить явный интерфейс. Это копия заголовка, спецификаций и оператора END соответствующей процедуры, либо помещенная в модуль, либо вставленная напрямую:

REAL FUNCTION minimum ( a , b , func ) ! возвращает минимальное значение функции func(x) ! в интервале (a,b) REAL , INTENT ( in ) :: a , b INTERFACE REAL FUNCTION func ( x ) REAL , INTENT ( IN ) :: x END FUNCTION func END INTERFACE REAL f , x : f = func ( x ) ! вызов пользовательской функции. : END FUNCTION minimum                        

Явный интерфейс обязателен для

• необязательные и ключевые аргументы;
• Аргументы POINTER и TARGET (см. Указатели);
• Результат функции POINTER;
• новый стиль аргументов массива и функций массива (обработка массивов).

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

В общем случае, лучший способ гарантировать, что интерфейс процедуры является явным, — это поместить соответствующую процедуру в модуль или использовать ее как внутреннюю процедуру.

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

INTERFACE gamma ! общее имя FUNCTION sgamma ( X ) ! конкретное имя REAL ( SELECTED_REAL_KIND ( 6 )) sgamma , x END  FUNCTION dgamma ( X ) ! конкретное имя REAL ( SELECTED_REAL_KIND ( 12 )) dgamma , x END END INTERFACE               

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

ИНТЕРФЕЙС гамма МОДУЛЬ ПРОЦЕДУРА sgamma , dgamma КОНЕЦ ИНТЕРФЕЙС  

Мы можем использовать существующие имена, например, SIN, и компилятор подберет правильную ассоциацию.

Мы уже видели использование интерфейсных блоков для определенных операторов и назначений (см. Модули).

Косвенная рекурсия полезна для многомерной интеграции.

объем = интегрировать ( fy , ybounds )   

Мы могли бы иметь

РЕКУРСИВНАЯ ФУНКЦИЯ интегрировать ( f , bounds ) ! Интегрировать f(x) от bounds(1) до bounds(2) REAL интегрировать INTERFACE  FUNCTION f ( x ) REAL f , x END FUNCTION f END INTERFACE REAL , DIMENSION ( 2 ), INTENT ( IN ) :: bounds : END FUNCTION интегрировать              

и проинтегрировать f(x, y) по прямоугольнику:

ФУНКЦИЯ fy ( y ) ИСПОЛЬЗОВАТЬ func ! модуль func содержит функцию f REAL fy , y yval = y fy = integrated ( f , xbounds ) END           

Прямая рекурсия — это когда процедура вызывает сама себя, как в

РЕКУРСИВНАЯ ФУНКЦИЯ факториал ( n ) РЕЗУЛЬТАТ ( res ) ЦЕЛОЕ ЧИСЛО res , n ЕСЛИ ( n . EQ . 0 ) ТО res = 1 ИНАЧЕ res = n * факториал ( n - 1 ) КОНЕЦ ЕСЛИ КОНЕЦ             

Здесь мы отмечаем RESULTусловие и тест на прекращение.

Это функция параллельных вычислений.

В операторе и конструкции FORALL любые побочные эффекты в функции могут помешать оптимизации на параллельном процессоре – порядок выполнения назначений может повлиять на результаты. Чтобы контролировать эту ситуацию, мы добавляем ключевое PUREслово к оператору SUBROUTINEor FUNCTION– утверждение, что процедура (выраженная просто):

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

Компилятор может проверить, что это так, например:

ЧИСТАЯ ФУНКЦИЯ вычислить ( x ) 

Все внутренние функции являются чистыми.

Обработка массивов включена в Fortran по двум основным причинам:

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

В то же время были добавлены серьезные расширения функционала в этой области. Целые массивы мы уже встречали выше #Arrays 1 и здесь #Arrays 2 - теперь развиваем тему.

Массив нулевого размера обрабатывается Фортраном как законный объект, без специального кодирования программистом. Таким образом, в

ДЕЛАТЬ i = 1 , n x ( i ) = b ( i ) / a ( i , i ) b ( i + 1 : n ) = b ( i + 1 : n ) - a ( i + 1 : n , i ) * x ( i ) КОНЕЦ ДЕЛАТЬ                

Для последней итерации, где , не требуется специального кода i = n. Отметим, что массив нулевого размера считается определенным; однако массив формы (0,2) не согласуется с массивом формы (0,3), тогда как является допустимым оператором «ничего не делать».x(1:0) = 3

Это расширение и замена для массивов предполагаемого размера. При наличии фактического аргумента, например:

РЕАЛЬНЫЙ , РАЗМЕРНОСТЬ ( 0:10 , 0:20 ) :: a : ВЫЗОВ подпрограммы ( a )​​​​     

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

ПОДПРОГРАММА sub ( da ) REAL , РАЗМЕР (:, :) :: da     

и это как если бы daбыли размерными (11,21). Однако мы можем указать любую нижнюю границу, и массив отобразится соответствующим образом.

РЕАЛЬНЫЙ , РАЗМЕРНОСТЬ ( 0 :, 0 :) :: da    

Передается форма, а не границы, где нижняя граница по умолчанию равна 1, а верхняя граница по умолчанию — соответствующему размеру.

Частичная замена использованного EQUIVALENCE предоставляется этой возможностью, полезной для локальных временных массивов, как в

ПОДПРОГРАММА swap ( a , b ) REAL , DIMENSION (:) :: a , b REAL , DIMENSION ( SIZE ( a )) :: work work = a a = b b = work КОНЕЦ ПОДПРОГРАММЫ swap                   

Фактическое хранилище обычно размещается в стеке.

Fortran обеспечивает динамическое распределение памяти; он опирается на механизм хранения кучи (и заменяет другое использование EQUIVALENCE). Примером создания рабочего массива для всей программы является

MODULE work_array INTEGER n REAL , DIMENSION (:,:,:), ALLOCATABLE :: work КОНЕЦ МОДУЛЬНОЙ ПРОГРАММЫ main USE work_array READ ( input , * ) n ALLOCATE ( work ( n , 2 * n , 3 * n ), STAT = status ) : DEALLOCATE ( work )                  

Рабочий массив может быть распространен по всей программе с помощью USE оператора в каждом программном модуле. Мы можем указать явную нижнюю границу и выделить несколько сущностей в одном операторе. Чтобы освободить мертвое хранилище, мы пишем, например,

ОСВОБОДИТЬ ( a , b ) 

Освобождение массивов происходит автоматически, когда они выходят из области видимости.

Мы уже встречались с присваиваниями и операциями целых массивов:

REAL , DIMENSION ( 10 ) :: a , b a = 0. ! скалярная трансляция; элементное присваивание b = SQRT ( a ) ! результат встроенной функции как объект массива          

Во втором назначении встроенная функция возвращает массив-значный результат для массив-значного аргумента. Мы можем сами написать функции массив-значные (они требуют явного интерфейса):

PROGRAM test REAL , DIMENSION ( 3 ) :: a = ( / 1. , 2. , 3. / ), & b = ( / 2. , 2. , 2. / ), r r = f ( a , b ) PRINT * , r СОДЕРЖИТ  ФУНКЦИЮ f ( c , d ) REAL , DIMENSION (:) :: c , d REAL , DIMENSION ( SIZE ( c )) :: f f = c * d ! (или какая-то более полезная функция c и d) КОНЕЦ ФУНКЦИИ f КОНЕЦ ПРОГРАММЫ test                                        

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

Большинство встроенных функций являются элементарными, и Fortran 95 расширяет эту возможность на невстроенные процедуры, тем самым обеспечивая эффект написания на Fortran 90 22 различных версий для рангов 0-0, 0-1, 1-0, 1-1, 0-2, 2-0, 2-2, ... 7-7, и является дополнительным средством оптимизации на параллельных процессорах. Элементарная процедура должна быть чистой.

ЭЛЕМЕНТАРНАЯ ПОДПРОГРАММА swap ( a , b ) REAL , INTENT ( INOUT ) :: a , b REAL :: work work = a a = b b = work КОНЕЦ ПОДПРОГРАММЫ swap                  

Фиктивные аргументы не могут использоваться в выражениях спецификации (см. выше), за исключением аргументов определенных внутренних функций ( BIT_SIZE, KIND, LEN, и числовых функций запроса (см. ниже).

Часто нам нужно замаскировать назначение. Это можно сделать с помощью WHERE, либо как оператор:

ГДЕ ( a /= 0.0 ) a = 1.0 / a ! избегайте деления на 0       

(примечание: проверка выполняется поэлементно, а не по всему массиву) или как конструкция:

WHERE ( a /= 0.0 ) a = 1.0 / a b = a ! все массивы одинаковой формы END WHERE          

или

ГДЕ ( a /= 0.0 ) a = 1.0 / a В ДРУГОМ МЕСТЕ a = ОГРОМНЫЙ ( a ) КОНЕЦ ГДЕ         

Дальше:

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

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

ДЛЯ ВСЕХ ( i = 1 : n ) a ( i , i ) = x ( i )      

где отдельные присваивания могут выполняться в любом порядке и даже одновременно. Их FORALLможно рассматривать как присваивание массива, выраженное с помощью индексов.

ДЛЯ ВСЕХ ( i = 1 : n , j = 1 : n , y ( i , j ) /= 0. ) x ( j , i ) = 1.0 / y ( i , j )     

с маскирующим состоянием.

Конструкция FORALLпозволяет выполнить несколько операторов присваивания по порядку.

а ( 2 : n - 1 , 2 : n - 1 ) = а ( 2 : n - 1 , 1 : n - 2 ) + а ( 2 : n - 1 , 3 : n ) + а ( 1 : n - 2 , 2 : n - 1 ) + а ( 3 : n , 2 : n - 1 ) б ( 2 : n - 1 , 2 : n - 1 ) = а ( 2 : n - 1 , 2 : n - 1 )          

эквивалентно присваиванию массива

ДЛЯ ВСЕХ ( i = 2 : n - 1 , j = 2 : n - 1 ) a ( i , j ) = a ( i , j - 1 ) + a ( i , j + 1 ) + a ( i - 1 , j ) + a ( i + 1 , j ) b ( i , j ) = a ( i , j ) КОНЕЦ ДЛЯ ВСЕХ                 

Версия FORALLболее читабельна.

Присваивание в a FORALLпохоже на присваивание массива: как если бы все выражения были оценены в любом порядке, удерживались во временном хранилище, затем все присваивания выполнялись в любом порядке. Первое выражение должно полностью завершиться, прежде чем второе может начаться.

A FORALLможет быть вложенным и может включать в себя WHERE. Процедуры, на которые ссылаются внутри , FORALLдолжны быть чистыми.

Для простого случая, учитывая

РЕАЛЬНЫЙ , РАЗМЕРНОСТЬ ( 100 , 100 ) :: а    

мы можем ссылаться на один элемент, например, a(1, 1). Для производного типа данных, например

ТИП fun_del REAL u REAL , РАЗМЕР ( 3 ) :: du КОНЕЦ ТИП fun_del     

мы можем объявить массив такого типа:

ТИП ( fun_del ), РАЗМЕР ( 10 , 20 ) :: tar    

и ссылка типа — это элемент (скаляр!) типа fun_del, но это массив типа real, и является его элементом. Основное правило, которое следует запомнить, заключается в том, что элемент массива всегда имеет индекс или индексы, квалифицирующие как минимум фамилию.tar(n, 2)tar(n, 2)%dutar(n, 2)%du(2)

Общая форма индекса для раздела массива:

 [ нижний ] : [ верхний ] [ : шаг ]

(где [ ] указывает на необязательный элемент), как в

REAL a ( 10 , 10 ) a ( i , 1 : n ) ! часть одной строки a ( 1 : m , j ) ! часть одного столбца a ( i , : ) ! вся строка a ( i , 1 : n : 3 ) ! каждый третий элемент строки a ( i , 10 : 1 : - 1 ) ! строка в обратном порядке a ( ( / 1 , 7 , 3 , 2 / ), 1 ) ! векторный индекс a ( 1 , 2 : 11 : 2 ) ! 11 допустимо, так как не ссылается a ( :, 1 : 7 ) ! раздел ранга два                        

Обратите внимание, что векторный индекс с повторяющимися значениями не может появляться в левой части присваивания, так как это будет неоднозначно. Таким образом,

б ( ( / 1 , 7 , 3 , 7 / ) ) = ( / 1 , 2 , 3 , 4 / )              

недопустимо. Также раздел с индексом вектора не должен быть предоставлен как фактический аргумент для аргумента- пустышки OUTили INOUTфиктивного аргумента. Массивы массивов не допускаются:

tar % du ! незаконный 

Отметим, что на заданное значение в массиве можно ссылаться и как на элемент, и как на раздел:

a ( 1 , 1 ) ! скаляр (ранг ноль) a ( 1 : 1 , 1 ) ! раздел массива (ранг один)    

в зависимости от обстоятельств или требований. Квалифицируя объекты производного типа, мы получаем элементы или разделы в зависимости от правила, указанного ранее:

tar % u ! раздел массива (компонент структуры) tar ( 1 , 1 )% u ! компонент элемента массива   

Умножение векторов и матриц

Сокращение массива

Запрос массива

Построение массива

Изменение формы массива

Манипуляции с массивами

Расположение массива

Указатели — это переменные с POINTERатрибутом ; они не являются отдельным типом данных (и поэтому никакая «арифметика указателей» невозможна).

РЕАЛЬНЫЙ , УКАЗАТЕЛЬ :: var   

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

ВЫДЕЛИТЬ ( var ) 

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

вар = вар + 2,3    

используется и изменяется значение цели var. Указатели не могут передаваться через ввод-вывод. Оператор

ЗАПИСЬ * , вар  

записывает значение цели var, а не сам дескриптор указателя.

Указатель может указывать на другой указатель и, следовательно, на свою цель или на статический объект, имеющий TARGETатрибут:

REAL , POINTER :: object REAL , TARGET :: target_obj var => object ! назначение указателя var => target_obj           

но они строго типизированы:

ЦЕЛОЕ ЧИСЛО , УКАЗАТЕЛЬ :: int_var var => int_var ! незаконно - типы должны совпадать      

и, аналогично, для массивов должны совпадать как ранги, так и тип.

Указатель может быть компонентом производного типа:

ТИП запись ! тип для разреженной матрицы REAL :: значение INTEGER :: индекс ТИП ( запись ), POINTER :: следующий ! примечание рекурсия КОНЕЦ ТИП запись            

и мы можем определить начало связанной цепочки таких записей:

ТИП ( запись ), УКАЗАТЕЛЬ :: цепь   

После соответствующих распределений и определений первые две записи можно рассматривать как

цепочка % цепочка создания стоимости % следующая % цепочка создания стоимости % индекс цепочка % следующая % индекс цепочка % следующая цепочка % следующая % следующая 

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

Статус ассоциации указателя — один из

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

Встроенная функция ASSOCIATEDможет проверить статус ассоциации определенного указателя:

ЕСЛИ ( АССОЦИИРОВАННЫЙ ( ptr )) ТОГДА