Просмотр кода страницы Фортран

{{не путать|Форт (язык программирования)|Фортом|другим языком программирования}}
{{Карточка языка программирования
| name = Фортран
| logo = 
| semantics = [[Императивное программирование|императивный]], [[Параллелизм (информатика)|параллельный]]
| paradigm = [[Процедурный язык программирования|процедурный]], [[Модульность (программирование)|модульный]], c элементами [[объектно-ориентированное программирование|объектно-ориентированного]] программирования
| class = [[Компилятор|компилируемый]]
| year = 1957
| designer = [[Бэкус, Джон|Джон Бэкус]], [[IBM]]
| extension = .for .f .f90 .f95 .ftn
| latest_release_version = Fortran 2023 (ISO/IEC 1539-1:2023)
| latest_release_date = 17 ноября 2023
| latest_preview_version = 
| latest_preview_date = 
| typing = [[Строгая типизация|строгая]], [[статическая типизация|статическая]]
| implementations = [[GFortran]], [[Open Watcom]], [[Sun Studio]], [[XL Fortran]], [[Intel Fortran Compiler|Intel Fortran]]
| dialects = [[High Performance Fortran]]
| influenced_by = 
| influenced = [[ALGOL 68]], [[Бейсик]], [[PL/I]]
| operating_system = [[Кроссплатформенное программное обеспечение|кроссплатформенный]]
| license = 
| website = 
}}
'''Фортра́н''' ({{lang-en|Fortran}}, {{IPAc-en|ˈ|f|ɔr|t|r|æ|n}}) — первый [[язык программирования высокого уровня]], получивший практическое применение, имеющий [[транслятор]]<!-- Более ранние разработки трансляторов, впрочем, не намного опередившие команду Дж. Бэкуса (см., например, статью http://www.iis.nsk.su/files/articles/mozaika_lyubimskii_pottosin_shura-bura.pdf), не вышли за пределы академического интереса и не получили практического применения. --> и испытавший дальнейшее развитие<ref>{{Книга|автор=В.Э. Карпов|заглавие=КЛАССИЧЕСКАЯ ТЕОРИЯ КОМПИЛЯТОРОВ|ответственный=|издание=Учебное пособие. 2-е изд.|место=Москва|издательство=|год=2011|страницы=|страниц=91|isbn=5–230–16344–5}}</ref>. Создан в период с 1954 по 1957 год группой программистов под руководством [[Бэкус, Джон|Джона Бэкуса]] в корпорации [[IBM]]<ref>Язык [[Планкалкюль]], претендующий на пальму первенства, был изобретён ещё в 1945 году, но не был реализован вплоть до 2000 года.</ref>. Название Fortran является сокращением от '''FOR'''mula '''TRAN'''slator (формульный транслятор)<ref>Словарь иностранных слов. — М.: «[[Русский язык (издательство)|Русский язык]]», 1989. — 624 с. ISBN 5-200-00408-8</ref>. Фортран широко используется в первую очередь для научных и инженерных вычислений. Одно из преимуществ современного Фортрана — большое количество написанных на нём программ и библиотек подпрограмм<ref>См., например: [http://netlib.org Netlib Repository at UTK and ORNL] {{Wayback|url=http://netlib.org/ |date=20210727103150 }}</ref>.

Имеется большое количество написанных на Фортране (в большей части на старых версиях языка) различных математических библиотек для [[Матрица (математика)|матричной алгебры]] и решения систем [[Линейное уравнение|линейных уравнений]], библиотеки для решения [[дифференциальное уравнение|дифференциальных уравнений]], [[интегральное уравнение|интегральных уравнений]] и их систем, [[Аппроксимация|аппроксимации функций]], [[Специальные функции|специальных функций]], [[Быстрое преобразование Фурье|быстрых преобразований Фурье]], математической статистики и других математических дисциплин. Эти библиотеки поставляются, как правило, с компилятором. Ряд таких пакетов создавался на протяжении десятилетий и популярен в научной среде по сей день, например — [[Международная математическая библиотека подпрограмм]] (IMSL)<ref>{{Cite web |url=http://www.roguewave.com/products-services/imsl-numerical-libraries/fortran-libraries |title=IMSL Fortran Numerical Library {{!}} Rogue Wave<!-- Заголовок добавлен ботом --> |access-date=2015-08-19 |archive-date=2015-08-16 |archive-url=https://web.archive.org/web/20150816131449/http://www.roguewave.com/products-services/imsl-numerical-libraries/fortran-libraries |url-status=live }}</ref><ref>{{Книга|автор=Бартеньев О.В.|часть=1-3|заглавие=Фортран для профессионалов. Математическая библиотека ISML|ответственный=|заглавие2=|издание=|место=Москва|издательство=Диалог-МИФИ|год=2001|том=|страниц=ч1 - 448 с., ч2 - 320 с., ч3 - 368|isbn=5-86404-157-2 (ч.2), 5-86404-18-58-0 (ч.3)|тираж=3000}}</ref>.

Большинство таких библиотек является фактически достоянием человечества: они доступны в исходных кодах, хорошо документированы, отлажены и весьма эффективны.

Современный Фортран (Fortran 95 и Fortran 2003) приобрёл черты, необходимые для эффективного программирования, для новых вычислительных архитектур; позволяет применять современные технологии программирования, в частности, [[Обобщённое программирование|обобщённое]] и [[Модульность (программирование)|модульное программирование]], [[объектно-ориентированное программирование|ООП]], сохраняя при этом преемственность с более ранними версиями. Одна из главных концепций развития современного Фортрана — средства поддержки [[Параллельные вычисления|параллельности]] и [[Векторизация (параллельные вычисления)|векторные операции]]<ref name="ЭволюцГорел" />.

== Эволюция стандартов языка ==
{| class="wikitable floatright" style="margin-left: 1.5em;"
|+Хронология Фортрана
|-
! Год
! Неформальное название
! Официальный стандарт
|-
| 1957
| FORTRAN
| {{n/a}}
|-
| 1958
| FORTRAN II
| {{n/a}}
|-
| 1958
| FORTRAN III
| {{n/a}}
|-
| 1961
| FORTRAN IV
| {{n/a}}
|-
| 1966
| FORTRAN 66
| ANSI X3.9-1966
|-
| 1978
| FORTRAN 77
| ANSI X3.9-1978
|-
| 1991
| Fortran 90
| ANSI X3.198-1992<br />ISO/IEC 1539:1991
|-
| 1997
| Fortran 95
| ISO/IEC 1539-1:1997
|-
| 2004
| Fortran 2003
| ISO/IEC 1539-1:2004
|-
| 2010
| Fortran 2008
| ISO/IEC 1539-1:2010
|-
| 2018
| Fortran 2018
| ISO/IEC 1539-1:2018
|-
| 2023
| Fortran 2023
| ISO/IEC 1539-1:2023
|}
Фортран — жёстко стандартизированный язык, поэтому он легко переносится на различные платформы. Новые стандарты языка в значительной мере сохраняют преемственность с более старыми, что позволяет использовать коды ранее написанных программ и модифицировать их<ref name="ЭволюцГорел">{{статья|автор=[[Горелик, Алла Моисеевна|Горелик А. М.]]|заглавие=Эволюция языка программирования Фортран (1957—2007) и перспективы его развития|издание=Вычислительные методы и программирование|год=2008|том=9|выпуск=|номер=|страницы=53—71|ссылка=http://num-meth.srcc.msu.ru/zhurnal/tom_2008/v9r208.html|doi=|arxiv=|bibcode=|язык=ru|archive-date=2015-04-02|archive-url=https://web.archive.org/web/20150402162524/http://num-meth.srcc.msu.ru/zhurnal/tom_2008/v9r208.html}}</ref>. При этом по мере развития языка заранее объявляются устаревшие конструкции, которые в будущем, возможно, будут удалены<ref name=":1">{{Книга|автор=Горелик А.М.|часть=Часть 2, Главы 14-20|заглавие=Программирование на современном Фортране|ответственный=|издание=|место=Москва|издательство=Финансы и статистика|год=2006|страницы=|страниц=352|isbn=5-279-03066-X|тираж=3000}}</ref>.

=== FORTRAN 66 (1966) ===
: Стандарт [[ANSI]] X3.9-1966<ref>{{Книга|ссылка=https://wg5-fortran.org/ARCHIVE/Fortran66.pdf|автор=ANSI|заглавие=X3.9-1966 - FORTRAN|год=1966|access-date=2021-02-18|archive-date=2020-11-01|archive-url=https://web.archive.org/web/20201101011422/https://wg5-fortran.org/ARCHIVE/Fortran66.pdf|url-status=live}}</ref> определил язык FORTRAN (основанный на FORTRAN IV фирмы IBM, который служил стандартом де-факто). Впоследствии на него стали ссылаться как на FORTRAN 66, хотя многие продолжали называть его FORTRAN IV, язык, на котором стандарт был в значительной степени основан.
[[Файл:Ftn-elim-1240x1709.jpg|thumb|Программа на FORTRAN-77 с выдачей компилятора]]

=== FORTRAN 77 (1978) ===
: ANSI X3.9-1978, ISO 1539:1980<ref>{{Cite web|lang=en|url=https://wg5-fortran.org/ARCHIVE/Fortran77.html|title=Fortran 77 - ANSI X3J3/90.4 Working Group|access-date=2021-02-18|archive-date=2020-11-11|archive-url=https://web.archive.org/web/20201111174213/https://wg5-fortran.org/ARCHIVE/Fortran77.html|url-status=live}}</ref>, введено множество улучшений<ref name="ЭволюцГорел" />:
# Введены операторы открытия и закрытия файла (<code>OPEN</code>, <code>CLOSE</code>) и вывода на стандартное устройство — <code>PRINT</code>.
# Добавлены строковый тип данных и функции для его обработки.
# Введён блочный [[Оператор (программирование)|оператор]] <code>IF</code> и конструкция <code>IF THEN</code> — <code>ELSE IF THEN</code> — <code>END IF</code>, а также оператор включения фрагмента программы <code>INCLUDE</code>.
# Введена возможность работы с файлами прямого доступа.
# Увеличена максимальная размерность массива с 3 до 7. Сняты ограничения на индексы массива.
# Усовершенствованы и расширены возможности работы с процедурами.
# Введено понятие внутреннего файла (каковыми являются массивы, числовые и строковые переменные). Внутренние файлы позволяют, в частности, осуществлять преобразование число-строка и строка-число стандартным операторами чтения и записи <code>READ</code> и <code>WRITE</code><ref name="БартеньевСФ" />.

=== Fortran 90 (1991) ===
: ISO/IEC 1539:1991 (ANSI INCITS 198—1992)<ref>{{Cite web|lang=en|url=https://wg5-fortran.org/N001-N1100/N692.pdf|title=Fortran 90 - Last Working Draft|website=wg5-fortran.org|access-date=2021-02-18|archive-date=2020-11-05|archive-url=https://web.archive.org/web/20201105092235/https://wg5-fortran.org/N001-N1100/N692.pdf|url-status=live}}</ref>, значительно переработан стандарт языка<ref name="БартеньевСФ">{{книга
|ссылка = http://lib.mexmat.ru/books/8926
|автор = Бартеньев О. В.
|заглавие = Современный Фортран
|место = М.
|издательство = Диалог МИФИ
|год = 2005
|isbn = 5-86404-113-0
|archive-date = 2011-02-10
|archive-url = https://web.archive.org/web/20110210080511/http://lib.mexmat.ru/books/8926
}}</ref> включая смену названия FORTRAN на Fortran.
# Введён свободный формат написания кода. Появились дополнительные описания <code>IMPLICIT NONE</code>, <code>TYPE</code>, <code>ALLOCATABLE</code>, <code>POINTER</code>, <code>TARGET</code>, <code>NAMELIST</code>.
# Введены управляющие операторы и конструкции. Добавлены <code>DO</code> … <code>END DO</code> (вместо завершения цикла меткой), <code>DO WHILE</code>, оператор передачи управления на начало цикла <code>CYCLE</code>, конструкция выбора <code>SELECT CASE</code> (для замены громоздких конструкций <code>IF</code> и операторов <code>GOTO</code>), а также заключительный оператор программной единицы, модульной или внутренней процедуры <code>END</code><ref name="ЭволюцГорел" />.
# Введён инструментарий указателей и функции для работы с оперативной памятью (по аналогии с языком С).
# Введены операторы работы с динамической памятью (<code>ALLOCATE</code>, <code>DEALLOCATE</code>, <code>NULLIFY</code>).
# Добавлены программные компоненты <code>MODULE</code>, <code>PRIVATE</code>, <code>PUBLIC</code>, <code>CONTAINS</code>, <code>INTERFACE</code>, <code>USE</code>, <code>INTENT</code>.
# Введено маскирование присваивания массивов (присваивание при выполнении наложенного на элементы массива логического условия без использования операторов условия), а также работа с сечениями массивов. Введён оператор и конструкция <code>WHERE</code> для частичной замены циклов (правая часть оператора присваивания не изменяется). Маскирование присваивания распространяется практически на все операторы, конструкции и функции, оперирующие с массивами.
# Стандартные операции присваивания, сложения, вычитания, а также деления и умножения на число распространены на массивы и их секции, определяемые сечениями. В этом случае осуществляется поэлементное присваивание.
# Появились новые встроенные функции, в первую очередь для работы с массивами. Функции для вычислений в массивах: <code>ALL</code> (логическое произведение) и <code>MASK</code> (логическое сложение), <code>COUNT</code> (число истинных элементов), <code>PRODUCT</code>(произведение элементов массива), <code>SUM</code> (сложение элементов массива), <code>DOT_PRODUCT</code> (скалярное произведение), <code>MATMUL</code> (умножение матриц). Добавились справочные функции, а также функции переформирования и свёртки массивов.
# В языке появились элементы [[объектно-ориентированное программирование|ООП]]<ref name="ГореликООП">''Горелик А. М.'' [http://www.ict.edu.ru/ft/004318/prep2002_70.pdf Объектно-ориентированное программирование на современном Фортране] {{Wayback|url=http://www.ict.edu.ru/ft/004318/prep2002_70.pdf |date=20110907185633 }}</ref>. Введены производные типы данных. Отдельно объявлен список устаревших черт языка, предназначенных для удаления в будущем.
# Добавлены дополнительные функции для работы со строковыми данными, в частности, функции <code>TRIM</code> (удаление завершающих пробелов) и <code>REPEAT</code> (кратное копирование строки) и функции выравнивания по левой и правой границам.

=== Fortran 95 (1997) ===
: ISO/IEC 1539-1:1997<ref>{{Cite web|lang=en|url=https://wg5-fortran.org/N1151-N1200/N1191.pdf|title=Fortran 95 - Last Working Draft|website=wg5-fortran.org|access-date=2021-02-18|archive-date=2021-07-01|archive-url=https://web.archive.org/web/20210701060345/https://wg5-fortran.org/N1151-N1200/N1191.pdf|url-status=live}}</ref>, коррекция предыдущего стандарта. Введён оператор и конструкция <code>FORALL</code>, позволяющие более гибко, чем оператор и конструкция <code>WHERE</code>, присваивать массивы и заменять громоздкие циклы. <code>FORALL</code> позволяет заменить любое присваивание сечений или оператор и конструкцию <code>WHERE</code>, в частности, обеспечивает доступ к диагонали матрицы. Данный оператор считается перспективным в параллельных вычислениях, способствуя более эффективному, чем циклы, осуществлению распараллеливания<ref>{{Книга|автор=Горелик А. М.|часть=3. Введение в параллельное программирование на Фортране|заглавие=Программирование на современном Фортране|ответственный=|издание=|место=Москва|издательство=Финансы и статистика|год=2006|страницы=|страниц=352|isbn=5-279-03066-X}}</ref><ref name="БартеньевСФ" /><ref name="Алгазин" />.

=== Fortran 2003 (2004) ===
: Принят как ISO/IEC 1539-1:2004<ref>{{cite web|title=Fortran 2003– Last Working Draft|url=http://www.j3-fortran.org/doc/year/04/04-007.txt|publisher=Gnu.Org|access-date=2014-05-10|archive-date=2021-02-25|archive-url=https://web.archive.org/web/20210225090124/https://j3-fortran.org/doc/year/04/04-007.txt|url-status=live}}</ref>. Дальнейшее развитие поддержки [[объектно-ориентированное программирование|ООП]] в языке. Взаимодействие с операционной системой. Добавлены также следующие возможности<ref name="ЭволюцГорел" />:
# Асинхронный ввод-вывод данных.
# Средства взаимодействия с языком '''[[Си (язык программирования)|C]]'''.
# Усовершенствование динамического размещения данных<ref name="Алгазин">{{книга
 |автор         = Алгазин С. Д., Кондратьев В. В.
 |заглавие      = Программирование на Visual Fortran
 |место         = М.
 |издательство  = «Диалог [[Национальный исследовательский ядерный университет «МИФИ»|МИФИ]]»
 |год           = 2008
 |страниц       = 448
 |isbn          = 5-8243-0759-8
}}</ref>.

=== Fortran 2008 (2010) ===
: ISO/IEC 1539-1:2010, общепринятое неформальное название Fortran 2008<ref>{{cite web|title=Fortran 2008 – Last Working Draft|url=http://www.j3-fortran.org/doc/year/10/10-007.pdf|publisher=Gnu.Org|access-date=2014-05-10|archive-date=2021-03-03|archive-url=https://web.archive.org/web/20210303181414/https://j3-fortran.org/doc/year/10/10-007.pdf|url-status=live}}</ref>. Стандартом предполагается поддержка средствами языка параллельных вычислений (Co-Arrays Fortran)<ref name="ЭволюцГорел" /><ref>Горелик А. М.[http://parallel.ru/tech/tech_dev/f2000.html Новости] {{Wayback|url=http://parallel.ru/tech/tech_dev/f2000.html |date=20120302101235 }}</ref>. Также предполагается увеличить максимальную размерность массивов до 15, добавить встроенные специальные математические функции<ref name="ЭволюцГорел" /> и др.

=== Fortran 2018 ===
: Версия языка Fortran 2018 (ранее известная как Fortran 2015) была выпущена 28 ноября 2018 года<ref name="F2018">{{cite web|url=https://wg5-fortran.org/f2018.html|publisher=ISO|title=Fortran 2018|access-date=2018-11-30|archive-date=2017-12-01|archive-url=https://web.archive.org/web/20171201030814/https://wg5-fortran.org/f2018.html|url-status=live}}</ref>.

: Fortran 2018 (ISO/IEC 1539-1:2018) включает в себя:
:* ISO/IEC TS 29113:2012 — Дальнейшая совместимость с C<ref name="TS29113">{{cite web|url=https://wg5-fortran.org/N1901-N1950/N1942.pdf|title=Further Interoperability with C|publisher=ISO|access-date=2017-11-20|archive-date=2021-03-08|archive-url=https://web.archive.org/web/20210308132136/https://wg5-fortran.org/N1901-N1950/N1942.pdf|url-status=live}}</ref>;
:* ISO/IEC TS 18508:2015 — Дополнительные параллельные функции в Fortran<ref name="TS18508">{{cite web|url=http://isotc.iso.org/livelink/livelink?func=ll&objId=17288706&objAction=Open|title=Additional Parallel Features in Fortran|publisher=ISO|access-date=2017-11-20}}</ref>.
: Также введены поддержка [[IEEE 754|ISO/IEC/IEEE 60559:2011]], шестнадцатеричный ввод/вывод чисел с плавающей точкой, усовершенствования IMPLICIT NONE и другие изменения.

=== Fortran 2023 ===
: Последняя версия языка Fortran — Fortran 2023 (ISO/IEC 1539-1:2023) была выпущена в ноябре 2023 года<ref>{{cite web |title=Fortran 2023 |url=https://wg5-fortran.org/f2023.html |website=wg5-fortran.org |access-date=2023-11-30}}</ref>.
:Fortran 2023 — это небольшое расширение Fortran 2018, которое в основном фокусируется на исправлении ошибок и упущений в Fortran 2018. Также добавлены некоторые новые небольшие функции, включая возможности работать с [[Перечисляемый тип|перечислением]].

== Возможности и характерные особенности языка ==
Фортран имеет большой набор встроенных математических функций, поддерживает работу с целыми, вещественными и комплексными числами двойной и повышенной точности (при бинарных операциях используется <code>real(10)</code>), имеет богатый инструментарий работы с массивами и внешними файлами. Современный Фортран (2003 и выше) имеет полноценный инструментарий для работы с символьными данными.

Изначально выразительные средства языка были не очень велики, поскольку Фортран был первым реализованным языком высокого уровня. В дальнейшем в Фортран были добавлены многие лексические конструкции, характерные для структурного, модульного, обобщённого и объектно-ориентированного программирования.

=== Формат записи кода ===
[[Файл:Hollerith card.jpg|thumb|300px|[[Перфокарта]] с разметкой колонок для Фортрана ранних версий.]]
Структура программ изначально была ориентирована на ввод с [[перфокарта|перфокарт]] и имела ряд удобных именно для этого случая свойств. Так, с 1-й по 5-ю колонку располагалась область меток, 6-я служила для маркировки текста как продолжения предыдущей строки (любым символом, кроме пробела и «0»), а с 7-й по 72-ю располагался собственно текст оператора или комментария. Колонки с 73-й по 80-ю могли служить для нумерации карт (чтобы восстановить случайно рассыпавшуюся колоду) или для краткого комментария, транслятором они игнорировались. Если текст оператора не вписывался в отведённое пространство (с 7-й по 72-ю колонку), в 6-й колонке следующей строки ставился признак продолжения, и затем оператор продолжался на ней. Расположить два или более оператора в одной строке (карте) было нельзя. Когда перфокарты ушли в историю, эти достоинства превратились в серьёзные неудобства.

Именно поэтому к стандарту Фортрана, начиная с Fortran 90, с сохранением фиксированного формата исходного текста, был добавлен ''свободный формат'', который не регламентирует позиции строки и позволяет записывать более одного оператора на строку. Введение свободного формата и современных способов [[Структурное программирование|структурного программирования]]<ref name="ЭволюцГорел" /> позволило создавать код, [[удобочитаемость|читаемость]] и ясность которого не уступает коду, созданному при помощи других современных языков программирования, таких как [[Паскаль (язык программирования)|Паскаль]], [[Си (язык программирования)|C]] или [[Java]]. Современные среды разработки позволяют комбинировать форматы: например, расширять длину строки до свободного формата (обычно 132 символа), позволяют записывать несколько операторов в строке, но при этом позволяют также сохранять отступ слева (делать левое поле), характерный для старого фиксированного формата, оставляя тем самым выделенную колонку для меток ошибок и форматов, а также колонку продолжения строки.

Своего рода «визитной карточкой» старого Фортрана является огромное количество меток, которые использовались в операторах безусловного перехода <code>[[GOTO]]</code>, операторах циклов, в условных операторах и в операторах описания форматного ввода-вывода <code>FORMAT</code>. Большое количество меток и операторов <code>GOTO</code> часто делало программы на Фортране трудными для понимания.

Именно этот негативный опыт стал причиной, по которой в ряде современных языков программирования (например, в языке [[Java]]) метки и связанные с ними операторы безусловного перехода сильно видоизменены.

Однако современный Фортран (в основном начиная с версии Fortran’90) избавлен от избытка меток за счёт введения таких операторов, как <code>DO</code> … <code>END DO</code>, <code>DO WHILE</code>, <code>SELECT CASE</code>, конструкции <code>IF THEN</code>-<code>ELSEIF THEN</code>-<code>ELSE</code>-<code>END IF</code> и др. Более того, в современных стандартах языка оставлен лишь классический оператор <code>GOTO</code>, применяемый во многих языках и поныне. Вычисляемый оператор <code>GOTO</code>, а также конструкция <code>ENTRY</code> — множественного входа в процедуры, — были исключены из стандарта, хотя, как правило, продолжают поддерживаться компиляторами.

==== Hello, World! ====
Фиксированный формат (символами «␣» выделены пробелы в позициях строки с 1 по 6):

<source lang="fortran" line="1">
␣␣␣␣␣␣PRINT*, 'Hello, World!'
␣␣␣␣␣␣END
</source>

Свободный формат:

<source lang="fortran" line="1">
print *, "Hello, World!"
end
</source>

'''Замечания.'''
* Оператор начала главной программы <code>PROGRAM</code> не является обязательным. Строго говоря, единственный обязательный оператор Фортран-программы — оператор <code>END</code>.
* Выбор прописных или строчных букв для написания операторов программы произволен. С точки зрения современных стандартов языка Фортран, множество прописных букв и множество строчных букв совпадают.

=== Типы данных ===
Фортран поддерживает 5 основных элементарных встроенных типов данных: ''действительный (<code>REAL</code>)'', ''комплексный (<code>COMPLEX</code>)'', ''целый (<code>INTEGER</code>)'' со знаком или без, ''логический (<code>LOGICAL</code>)'' и ''символьный (<code>CHARACTER</code>)''. Кроме того, возможно создавать производные типы данных с помощью ключевого слова <code>TYPE</code>. С самого начала создания языка существовали 4 типа данных: действительный, комплексный, целый и логический.

Существует понятие ''разновидности типа данных'' или ''параметры типа.'' Это позволяет параметризовать вещественные и комплексные данные (то есть указывать точность и диапазон десятичного порядка) и другие данные, повышая мобильность приложений.

Для всех числовых данных определены обычные арифметические операции и присваивания, существуют встроенные функции. Встроенная функция <code>Log(''x'')</code> в качестве аргумента <code>''x''</code> может иметь только ''действительное'' или ''комплексное'' число (''не целое'').

Как правило, для действительных чисел «одинарной» точности отводится 4 байта (<code>REAL(4)</code>, или параметр разновидности типа <code>KIND=4</code>), «двойной» — 8 байт. Для комплексных чисел число байт удваивается.

Целые числа могут занимать от 1 до 4 байт. Современные компиляторы позволяют программисту оперировать числами и «учетверённой» точности.

В арифметических операциях изменение типа производится по умолчанию от целого в действительное и далее комплексное число, либо применением специальной встроенной числовой функции. Так, эквивалентны следующие выражения (''i'' — целое): <code>Log(''i*''1''.'')</code> и <code>Log(real(''i''))</code>.

''Строковые (символьные) данные'' задаются с указанием длины в скобках либо после атрибута типа, либо после имени строки. Для задания строки в теле программы используются одинарные или двойные кавычки. Так, эквивалентны записи: ''A='It is hot''' или ''A="It is hot"''. Это удобно в тех случаях, когда в самой строке присутствуют кавычки: ''B="It isn’t hot"''.

Для строк существует встроенная операция конкатенации (сложения) строк: <code>//</code>. Существует 17 специализированных встроенных функций для символьных данных (помимо универсальных, обрабатывающих все типы данных).

''Метки'' — это целые числа с числом цифр не более 5; символы не допускаются. Метки используются в операторах <code>GO TO</code>, операторах чтения, записи и форматирования, а также при обработке ошибок и исключений. Помимо меток, в Фортране имеется возможность ''именовать'' управляющие конструкции (циклы, логические условия, конструкции <code>FORALL</code>… <code>END FORALL</code>, <code>WHERE</code>… <code>END WHERE</code>, <code>SELECT CASE</code>… <code>END SELECT</code>, <code>TYPE</code>… <code>END TYPE</code> и др.), причём имя конструкции может содержать любые допустимые в именах переменных символы.

==== Встроенные функции для символьных данных ====
Для преобразования ''число-символ'': <code>CHAR(i)</code> и <code>ACHAR(i)</code>. Преобразуют целое в соответствующий ему символ операционной системы или символ таблицы [[ASCII]].

Для преобразования ''символ-число'': <code>ICHAR(i)</code> и <code>IACHAR(i)</code>. Осуществляют обратные преобразования.

''Функции сравнения строк'': <code>LGE(A,B)</code>, <code>LGT(A,B)</code>, <code>LLE(A,B)</code> и <code>LLT(A,B)</code>. Результат функций — «истина», если длины строк (''L(A)'' и ''L(B)''), выраженные в символах ASCII, удовлетворяют следующим неравенствам соответственно: ''L(A)<math>\geqslant</math>L(B), L(A)<math>></math>L(B), L(A)<math>\leqslant</math>L(B)'' и ''L(A)<math><</math>L(B)''.

''Функции длины'': <code>LEN(A)</code> и <code>LEN_TRIM(A)</code>. Первая возвращает длину строки ''А'' (количество символов), вторая — возвращает длину строки без завершающих пробелов, если они имеются.

''Функции преобразования'': <code>TRIM(A)</code>, <code>ADJUSTL(A)</code> и <code>ADJUSTR(A)</code>, <code>REPEAT(A,N)</code>. Функция <code>TRIM(A)</code> возвращает строку ''A'' без завершающих пробелов. Функции <code>ADJUSTL(A)</code> и <code>ADJUSTR(A)</code> выравнивают строку (удаляют пробелы) слева и справа соответственно. Функция <code>REPEAT(A,N)</code> возвращает ''N'' копий строки ''А''.

''Функции поиска в строке:'' <code>SCAN(A,B,[''back''])</code>, <code>INDEX(A,B,[''back''])</code>, <code>VERIFY(A,B,[''back''])</code>. Факультативный параметр ''back'' определяет направление поиска: по умолчанию слева (для <code>''back=.false.''</code>) направо (для <code>''back=.true.''</code>).

Функция <code>SCAN</code> определяет номер позиции в строке ''A'' (слева или справа) первого найденного символа из списка-строки ''В''. Если результат отрицательный, то функция возвратит целочисленный 0. Функция <code>INDEX</code> определяет номер позиции, с которой впервые начинается ''полное'' вхождение строки ''В'' в строку ''А''. Причём поиск может вестись как слева, так и справа, но номер позиции исчисляется всегда ''слева,'' от начала строки. При неудачном поиске функция возвратит 0. Функция <code>VERIFY</code> ''обратна'' функции <code>INDEX</code>. Так, <code>VERIFY</code> возвращает номер позиции такого символа строки ''A'', которого ''нет'' в строке-маске ''В''. Если же ''все'' (различные) символы строки А ''присутствуют'' в строке-маске В, то функция вернёт 0.

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

Стандарты Фортрана, начиная с версии 2003, предусматривают возможность работы с символами [[Юникод]]а.

Помимо указанных возможностей, Фортран позволяет обрабатывать символьные данные средствами своего встроенного [[Фортран#Работа с массивами|матричного (векторного) анализа]], что существенно повышает гибкость обработки символьных данных.

В Фортране для совместимости с программами, написанными на языке Си, существует понятие ''Си-строки'', которая задаётся добавлением символа ''с'' после кавычки: ''А='Это Си-строка’с''. Нулевая строка будет задана так: ''А='\0’c''.

=== Подпрограммы (процедуры и функции) ===
Подпрограммы в Фортране существовали с самого первого стандарта и поныне являются одним из главных инструментов программирования<ref name="ЭволюцГорел"/>.

В Фортране вызов подпрограмм, функций и передача их параметров происходят исключительно [[вызов по ссылке|по ссылке]] (а не [[вызов по значению|по значению]]). Поэтому подпрограмма может изменить переданный ей аргумент в главной программе, если специальным образом это не предотвратить. Такой механизм позволяет сделать естественной нотацию при записи математических формул и сохранить при этом высокое быстродействие при работе с большими массивами данных<ref>{{Книга|автор = Трой Дуглас, Douglas A. Troy. пер. с англ. Б. А. Кузьмина|заглавие = Программирование на языке Си для персонального компьютера IBM PC|ответственный = И. В. Емелин|издание = |место = Москва|издательство = "Радио и связь"|год = 1991|страницы = |страниц = 432|isbn = 5-256-00707-6, 0-316-85311-9|оригинал = Complete C Language Programming for the IBM-PC}}</ref>.

Подпрограммы Фортрана могут содержать в списке параметров (называемых формальными параметрами) и необязательные (опциональные) параметры, а могут вообще не содержать параметров.

Стандарт языка позволяет осуществлять [[Перегрузка процедур и функций|перегрузку процедур и операций]] посредством родового интерфейса, объединяя различные процедуры (оперирующая каждая, например, целыми, действительными, комплексными числами и символьными переменными) под одним (родовым) именем. В этом случае в главной программе достаточно обратиться к родовой процедуре, а характер выполняемых операций будет зависеть от типа данных, предложенных процедуре для обработки. По такому принципу сделаны все встроенные функции и подпрограммы, например, <code>COS(x)</code>. Перегрузка процедур, функций и операторов (причём символы перегруженных операторов программист может предложить свои, помимо встроенных) распространяется не только на встроенные типы данных, но и на типы, определённые программистом<ref name="БартеньевСФ"/>.

==== Виды подпрограмм ====
Процедуры разделяются на ''подпрограммы'' и ''функции''. Подпрограммы удобнее, если необходимо возвратить большое число разнородных результатов; функции — при возвращении результата одного типа (в том числе массива).

Подпрограмма определяется оператором описания <code>Subroutine</code> ''имя_подпрограммы (список формальных аргументов)'', функция — оператором <code>Function</code> ''имя_функции (список формальных аргументов)''.

Вызов подпрограммы осуществляется оператором <code>Call</code> ''имя_подпрограммы (список фактических аргументов)''. Вызов функции осуществляется по имени с указанием списка фактических аргументов и без использования какого-либо специального оператора.

Начиная со стандарта F’90 поддерживаются ''рекурсивные'' процедуры (отсутствовавшие в ранних версиях из-за ограниченной машинной памяти), для объявления которых необходим явный спецификатор <code>recursive</code>. При этом результат функции должен отличаться от имени самой функции.

''Чистые процедуры и функции'' (<code>pure subroutine [function]</code>) — введённые стандартом F’95 процедуры и функции, не имеющие побочных эффектов. Чистая функция должна возвращать значение и не должна изменять ни одного из своих входных параметров и/или глобальных данных; чистая процедура должна изменять только те параметры, которые явно указаны как результирующие (выходные) посредством атрибута <code>intent(out</code> или <code>inout)</code>). Возможность побочных эффектов в Фортране (то есть, в конечном итоге, возможность изменения переменных в главной программе через подпрограмму) — побочное следствие быстрого метода передачи по адресу.

Чистые программные единицы не могут содержать операторов В/В (<code>WRITE</code> и <code>READ</code>) во внешние файлы и устройства, включая клавиатуру и экран, а также операторов паузы и останова программы.

Все встроенные функции и подпрограммы Фортрана, в том числе математические (кроме обращающихся к операционной системе, функций даты и времени, а также датчиков случайных чисел) являются чистыми, то есть не создают побочных эффектов. Чистые функции введены с целью повышения культуры программирования и повышения эффективности распараллеливания алгоритмов<ref name=":0">{{Книга|автор=Горелик А.М.|часть=Часть 1, Главы 1-13|заглавие=Программирование на современном Фортране|ответственный=|издание=1|место=Москва|издательство=Финансы и статистика|год=2006|страницы=|страниц=352|isbn=5-279-03066-X}}</ref><ref name=":1" />.

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

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

''Формальные аргументы'' — это аргументы подпрограммы (функции), указанные при её описании. При отсутствии аргументов у подпрограммы, скобки могут быть опущены. У функции скобки расставляются и при отсутствии формальных аргументов. Формальный параметр-процедура называется ''формальной процедурой''.

''Фактические аргументы'' — это аргументы, передаваемые подпрограмме или функции для выполнения при её вызове. Функция без аргументов вызывается с пустым списком в скобках, подпрограмма — без скобок.

Формальные и фактические аргументы должны быть ''согласованы''. Типы аргументов и разновидности их вида должны быть одинаковыми, массиву должен соответствовать массив (или сечение массива) той же конфигурации.

Существуют массивы, ''перенимающие конфигурацию'' и ''перенимающие размер'' как формальные аргументы процедур. ''Массив, перенимающий конфигурацию'' — это формальный аргумент-массив, который наследует конфигурацию соответствующего ему фактического массива. У такого массива при его объявлении задаётся размерность (совпадающая с размерностью фактического аргумента-массива) и опускаются верхние границы. По умолчанию нижние границы равны 1, но могут быть заданы произвольными. Число и значение элементов массива, перенимающего конфигурацию, точно наследуются от фактического аргумента-массива. ''Массив, перенимающий размер'' — это оставленный для совместимости более ранний, свойственный языку Fortran’77, способ описания наследующих массивов. У таких массивов наследуется только последнее измерение, верхняя граница которого описывается звёздочкой (<code>*</code>). При этом формальный и фактический массивы-аргументы могут иметь разную размерность. Массивы, перенимающие конфигурацию и размер, не могут быть динамическими или быть указателями. Процедуры, имеющие наследующие массивы, должны иметь явный интерфейс.

Строки-формальные аргументы также могут наследовать (перенимать) длину у соответствующего фактического аргумента-строки. ''Строки, перенимающие длину'', описываются посредством символа <code>*</code>: <code>Character (Len = *)</code> ''имя_строки''. При явном задании длины строки, длина строки-формального аргумента не может быть больше соответствующего фактического аргумента-строки.

Аргументы бывают ''позиционными'' и ''ключевыми''. ''Позиционные'' формальные и фактические аргументы связываются друг с другом по порядку их расположения в списке аргументов, который должен совпадать. ''Ключевые'' — по имени ключа, который совпадает с именем формального аргумента. Ключевые позволяют нарушить порядок следования аргументов или пропустить часть из них. Так, для подпрограммы с заголовком <code>Subroutine</code> ONE (A, B, C, D) вызов может быть таким: <code>Call</code> ONE (D=''Z'', C=''Y'', B=''X'', A=''W''), где ''W, X, Y, Z'' — фактические аргументы.

Ключевые аргументы позволяют иметь ''необязательные аргументы'', которые могут быть опущены. В этом случае необязательные аргументы должны иметь атрибут <code>Optional</code>. Например, если задано <code>Optional</code> ''C, D'', то в этом случае возможен вызов <code>Call</code> ONE (B=''X'', A=''W'').

Процедуры с необязательными параметрами должны иметь явный интерфейс.

=== Работа с массивами ===
Массивы — центральный пункт философии Фортрана. Все конструкции языка, данные, программные единицы, операторы, встроенные функции, циклы созданы и создаются для эффективной обработки прежде всего массивов. Фортран по мере своего развития следует принципу максимального, насколько это возможно, ухода от детального (поэлементного) описания и обработки массивов. Особенно это эффективно при обработке многомерных массивов (предельная размерность массивов стандарта F2008 — 15).
Такой взгляд на массивы не был свойственен ранним версиям языка; первые элементы обобщённого подхода к массивам появились в FORTRAN77; развиваются они и поныне.

Массивы бывают ''статическими'' и ''динамическими''. Динамические разделяются на ''размещаемые'' и ''автоматические'' (образуемые при вызове подпрограммы). Элементы двумерного массива в Фортране размещаются ''по столбцам'', а не по строкам, как, например, в [[Си (язык программирования)|Си]]. Таким образом, быстрее всего изменяется первый индекс массива. Поэтому для эффективной работы с массивами во вложенных циклах следует индексировать внутренние циклы левыми индексами, а внешние — правыми. По умолчанию присваивание, ввод, вывод и инициализация массивов осуществляются по столбцам.
<source lang="fortran" line="1">
do k=1,10
 do j=1,20
  do i=1,100
arr(i,j,k)=25 ! правильно
brr(k,j,i)=0  ! работоспособно, но медленнее в несколько раз

end do; end do; end do
</source>
Массивы могут быть нулевого размера (в том числе, если нижняя граница превосходит верхнюю). Индексами границ массивов могут быть любые целые числа. По умолчанию нижняя граница равна 1.
<source lang="fortran" line="1">
Real, allocatable::  ArR(:,:,:)  ! объявление размещаемого динамического действительного массива 
Integer, allocatable:: ArI(:), ArSI(2,5)  ! целых динамического и статического массивов
Character(32), allocatable:: ArC(:), ArC2(20) ! динамического массива строк длиной 32 символа и статического массива строк

Allocate(ArR(-74:0,8,1:3), ArI(0), ArC(1:-1))  ! размещение динамических массивов
print *, size(ArR), size(ArI), size(ArC), size(ArSI)    ! 1800    0    0    10

ArC2(17)(5:27)='Это присваивание строки' ! В строку номер 17 будет записано ␣ ␣ ␣ ␣ Это␣ присваивание␣ строки␣ ␣ ␣ ␣ ␣
...
</source>

==== Сечения массивов, операторы <code>FORALL</code> и <code>WHERE</code> ====
Фортран позволяет эффективно присваивать массивы без циклов посредством ''маскирования присваивания'' с помощью операторов <code>WHERE</code> и <code>FORALL</code>, а также ''сечений массивов'' и ''векторных индексов''. Во всех случаях первоначально вычисляется правая часть выражения целиком (для всех индексов массива) и лишь затем выполняется присваивание для индексов, удовлетворяющих массиву-маске. Вычисления с помощью этих инструментов позволяют повышать быстродействие и облегчают компилятору работу по выделению участков программы, которые могут быть выполнены независимо, то есть распараллелены.
<source lang="fortran" line="1">
Real:: arr(I1:I2,J1:J2,K1:K2), arr1(I1:I2,J1:J2,K1:K2), arr2(I1:I2,J1:J2,K1:K2)
Real:: frr(100), frr1(10)/1,2,3,3*4,4*5/
                ! или
Real:: frr1(10)=(/1,2,3,4,4,4,5,5,5,5/)

...
arr=1.  ! присваивание массива (встроенная перегрузка для оператора присваивания)
arr1=Sin(arr)+arr ! элементная функция sin применяется к каждому элементу массива

arr2(I1:I2:1,J1:J2:2,K2:K1:-4)=arr1(I1:I2:1,J1:J2:2,K2:K1:-4) ! присваивание элементов с шагом 1, 2 и -4 (назад), заданное индексным триплетом

frr=(/(J, J=1,100)/) ! присваивание одномерного массива посредством циклического списка

Forall(i=I1:I2, j=J1:J2, k=K1:K2, arr(i,j,k)>0.)  brr(i,j,k)=Log(arr(i,j,k))  ! замена циклов и условных операторов и конструкций. Маскирование присваивания (маска — arr(i,j,k)>0.)

Forall(i=1:N, j=1:N, k=1:N) crr(i,j,k)=Sin(0.5*(i+j)-k)    ! расширение возможностей сечений

Forall(i=1:100) ! конструкция Forall для нескольких операторов присваивания
 drr(i,i)=0.    ! доступ к диагонали матрицы
 err(i,i,i)=1.  ! и диагонали трёхмерного массива
End Forall
</source>

Возможны менее очевидные операции:
<source lang="fortran" line="1">
Integer V(-2:2,1:5)

V=reshape(source=(/(i, i=1,25)/), shape=(/5,5/)) ! инициализация массива порядковыми номерами с помощью конструктора массива и функции переформирования   
	print *, V   ! Вывод в DOS-окно будет произведён по строкам        
! 1           2           3           4           5 — 1-й столбец
! 6           7           8           9          10 — 2-й 
! 11          12         13          14          15 — 3-й
! 16          17         18          19          20 — 4-й
! 21          22         23          24          25 — 5-й

V(2,3:4)=V(-1:0,1) ! Повернуть кусочек массива
	print *, V   ! Вывод в DOS-окно будет произведён по строкам
! 1           2           3           4           5
! 6           7           8           9          10
! 11          12         13          14          2      замена в 3-м столбце 15 на 2 
! 16          17         18          19          3      замена в 4-м  столбце 20 на 3
! 21          22         23          24          25
</source>

Возможности оператора и конструкции <code>FORALL</code>, введённого стандартом F’95, шире возможностей оператора и конструкции <code>WHERE</code>, однако последний в некоторых случаях логического ветвления позволяет упростить код ввиду наличия альтернативы <code>ELSEWHERE</code>, избегая вложенных условных операторов и сложносоставленных массивов-масок.

Оператор и конструкция <code>FORALL</code> допускает использование только [[Фортран#Подпрограммы|чистых процедур и функций]]. При маскировании присваивания в операторах <code>WHERE</code>, <code>FORALL</code>, а также в специальных встроенных функциях для массивов (например, <code>SUM</code>) логический массив-маска вычисляется до присваивания и позволяет заменять циклы с логическими условиями внутри них, что позволяет избежать дополнительной работы для [[Предсказатель переходов|предсказателя переходов]] микропроцессора.

''Векторный индекс'' — целочисленный одномерный массив, значения которого — индексы некоторого другого массива. Векторные индексы используются для создания произвольных сечений многомерных массивов и являются их обобщениями. При использовании векторных индексов следует следить за повторяющимися значениями индексов в левой части оператора присваивания, так как в этом случае будет осуществлена попытка записи в одну ячейку памяти, возможно, разных значений. Порядок индексов — произвольный (хотя этим не следует злоупотреблять во избежание снижения быстродействия).
<source lang="fortran" line="1">
Integer vi(5)/7,7,7,3,8/, vj(4)/1,2,3,10/  ! инициализация массивов - векторных индексов
Real arr(20,20), brr(10,10) 
brr=0.; arr=1.              
         ! векторные индексы можно задавать и внутри использующего их массива
brr((/8,6,2,1,4/),vj)=arr(vi,vj) ! размерность векторных индексов должна совпадать слева и справа, а их значения - не выходить за пределы границ использующих их массивов
               ! размер векторных индексов может быть меньше размера рабочих массивов  
</source>

==== Встроенные функции для массивов ====
В современном Фортране имеется большое количество специализированных встроенных функций для работы с численными и символьными массивами (помимо разобранных выше общих способов). Аргументами функций выступают численный и/или символьный массив ''array'', логический массив ''mask'' (являющийся, например, условием ''array>0'') и измерение ''dim'' массива ''array'', формирующее (если задан аргумент ''dim'') сечение массива вдоль одного из измерений с номером ''dim''. Массив ''array'' может быть, если не указано иное, целочисленным, содержать действительные или комплексные числа. Если массив-маска не задан, то его значение считается тождественно истинным. Логический массив ''mask'', если задан, должен иметь ту же форму, что и массив ''array'', либо скалярное значение <code>.TRUE.</code>. <br>
Основная масса функций введена стандартом F’90.

<code>ALL(mask[, dim])</code> — логическая функция; возвращает «истина», если все элементы логического массива mask истинны (вдоль факультативного измерения ''dim'') и наоборот в противном случае.<br>
<code>ANY(mask[, dim])</code> — логическая функция; имеет значение «истина», если хотя бы один элемент логического массива mask истинен (вдоль факультативного измерения ''dim'').<br>
<code>COUNT(mask[, dim])</code> — целочисленная функция; результат равен числу истинных элементов массива ''mask'' (вдоль факультативного измерения ''dim'').

<code>MAXLOC(array[, mask][, dim])</code>, <code>MINLOC(array[, mask][, dim])</code>,
<br> — целочисленные функции, возвращающие соответственно индекс максимального и минимального элемента (или индексы максимальных и минимальных элементов) вдоль факультативного измерения ''dim'' для элементов, удовлетворяющих массиву-маске. Функции возвращают индекс первого по порядку следования элемента массива ''array''. Если аргумент функций ''dim'' не задан, или если ''array'' — одномерный массив, то результат записывается в одномерный массив.<br>
Для многомерных массивов ''array'' результат записывается в массив с рангом, на единицу меньшим ранга массива ''array'' (исключается измерение с номером ''dim'').

Значения индексов отсчитываются по порядку от нижних границ массива. То есть в случае, если номер нижней границы массива ''array'' отличается от единицы, то для доступа к максимальному или минимальному элементу массива следует прибавить к результату функций <code>MAXLOC</code> и <code>MINLOC</code> разницу между индексом нижней границы и единицей.
 
<code>MAXVAL(array[, mask][, dim])</code>, <code>MINVAL(array[, mask][, dim])</code> — функции поиска максимального и минимального элемента соответственно в массиве ''array'' для элементов, удовлетворяющих логическому массиву-маске ''mask'' вдоль факультативного измерения ''dim''.
Результат функции — такого же типа и разновидности, что и массив ''array''. Массив ''array'' может быть только вещественным или целочисленным.<br>
Для одномерного массива ''array'' или при отсутствии аргумента ''dim'' результатом является скаляр, иначе — массив с рангом, на единицу меньшим ранга массива ''array''.

<code>FINDLOC(array, value[, dim][, mask])</code> — целочисленная функция, возвращающая индекс равного ''value'' элемента массива ''array''. Введена стандартом F2008. Искомые элементы массива удовлетворяют логическому массиву-маске ''mask'' вдоль факультативного измерения ''dim''. Тип аргумента ''value'' должен совпадать с типом массива ''array'' и может быть любого встроенного типа (включая комплексный, логический или символьный). Остальные свойства функции аналогичны свойствам функций <code>MAXLOC</code> и <code>MINLOC</code>.

Начиная со стандарта F2003, функции <code>MAXLOC</code> и <code>MINLOC</code>, как и функция <code>FINDLOC</code>, оперируют также и символьными данными.

<code>SUM(array[, mask][, dim])</code> и <code>PRODUCT(array[, mask][, dim])</code> осуществляют соответственно суммирование и умножение элементов массива. Смысл аргументов функций <code>SUM</code> и <code>PRODUCT</code> тот же, что и у выше рассмотренных функций. <br>
Функция <code>PRODUCT</code> оперирует комплексными данными, начиная со стандарта F2003.

<code>DOT_PRODUCT(vector_1, vector_2)</code> осуществляет [[скалярное произведение]] по правилам [[Линейная алгебра|линейной алгебры]] векторов ''vector_1'' и ''vector_2'' (одномерных массивов) одинакового размера. Одномерные массивы ''vector_1'' и ''vector_2'' могут содержать данные любого численного и логического типа. Вектора ''vector_1'' и ''vector_2'' могут быть либо оба численными, либо оба — логическими.

<code>MATMUL(matrix_a, matrix_b)</code> — встроенная функция матричного перемножения. Перемножает две матрицы, матрицу на вектор, вектор на матрицу по правилам линейной алгебры. Аргументы функции ''matrix_a'' и ''matrix_b'' — двумерные или одномерные численные (любых встроенных численных типов) или логические массивы. Аргументами функции не могут быть одновременно два вектора: один из аргументов обязан быть матрицей (двумерным массивом). Число элементов первого (либо единственного) измерения массива ''matrix_b'' должно быть равно числу элементов последнего измерения массива ''matrix_a''. Введена стандартом F’90.<br>
В некоторых случаях при расчёте произведения вектор-столбца на вектор-строку, требующего при использовании функции <code>MATMUL</code> дополнительного преобразовывания векторов в матрицы формы <code>(/m,1/)</code> и <code>(/1,n/)</code>, эффективность <code>MATMUL</code> по данным Бартеньева<ref name="БартеньевСФ" /> заметно уступает обычному вложенному циклу.<br>
По тестам NASA<ref>{{Cite web|url = https://modelingguru.nasa.gov/docs/DOC-1762|title = Comparing Python, NumPy, Matlab, Fortran, etc.|author = Thomas Clune|work = NASA Modeling Guru|date = Nov 2, 2009 10:33 AM|publisher = |access-date = 2015-10-07|archive-date = 2015-10-23|archive-url = https://web.archive.org/web/20151023014748/https://modelingguru.nasa.gov/docs/DOC-1762|url-status = live}}</ref> для произведения матриц (двумерных массивов) быстродействие <code>MATMUL</code> компилятора фирмы Intel при использовании полной оптимизации ''[http://parallel.uran.ru/node/28 -O3]'' существенно (в некоторых случаях — на порядок) превышает быстродействие вложенных циклов, хотя для матриц размером ~1000×1000 и больше несколько уступает быстродействию подпрограммы [http://www.netlib.org/lapack/explore-html/d7/d2b/dgemm_8f_source.html DGEMM] библиотеки [http://www.netlib.org/lapack/explore-html/index.html LAPAK]. В то же время для матриц ~100×100 и меньше <code>MATMUL</code> превосходит по скорости DGEMM. Компилятор Фортрана фирмы IBM, начиная с версии F’90, использует для <code>MATMUL</code> [[алгоритм Винограда — Штрассена]] со сложностью <math>{\rm O}(n^{2.81})</math><ref>{{Статья|автор=Craig C. Douglas, Gordon Slishman|заглавие=Variants of Matrix-matrix Multiplication for Fortran-90|ссылка=http://doi.acm.org/10.1145/181498.181500|издание=SIGNUM Newsl.|год=1994-04-01|том=29|выпуск=2|страницы=4–6|issn=0163-5778|doi=10.1145/181498.181500|access-date=2016-05-25|archive-date=2021-08-09|archive-url=https://web.archive.org/web/20210809093344/https://dl.acm.org/doi/10.1145/181498.181500|url-status=live}}</ref>. Отметим, что стандартом алгоритмические реализации математических функций обычно не оговариваются и остаются на усмотрение разработчика компилятора.

<code>MERGE(t_source, f_source, mask)</code> — функция, создающая новый массив под управлением маски-массива ''mask'' из элементов массивов ''t_source'' и ''f_source'' той же формы и того же размера, что и исходные массивы. Массивы-аргументы и массив-результат могут быть любого встроенного типа и совпадать по типу данных, размеру и форме. <br>
Если элемент ''mask'' есть истина (<code>.ТRUE.</code>), то соответствующий ему элемент массива-результата равен соответствующему элементу массива ''t_source''; если ложь (<code>.FALSE.</code>) — то элементу массива ''f_source''.<br>
Аргументами функции могут быть скаляры; в этом случае, например, <code>MERGE(a,0,c>=0)</code>=a·''Θ(с)'', где ''Θ(с)'' — целочисленная [[Функция Хевисайда|функция Хэвисайда]].

<code>MOVE_ALLOC(from, to)</code> — встроенная подпрограмма, позволяющая динамически переразмещать ранее размещённый динамический массив ''to'' с новыми границами и размером, как у динамического массива ''from''. При этом данные из массива ''from'' копируются в массив ''to''. Тип данных и ранг массивов ''from'' и ''to'' должны совпадать. После переразмещения массива ''to'' массив ''from'' освобождает память и становится неразмещённым. Может быть полезна в численных методах с изменяющейся дискретизацией задачи ([[Многосеточный метод|многосеточных]] и [[Сетка (расчётная)#Адаптивные сетки|адаптивных]] методах). <br>
Введена стандартом F2003.

<code>TRANSPOSE(matrix)</code> — функция, [[Транспонированная матрица|транспонирующая]] (меняющая местами строки и столбцы) двумерную матрицу.

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

<code>PACK(array, mask [, vector])</code> — функция; упаковывает многомерный массив любого типа ''array'' в одномерный массив-вектор под управлением логического массива ''mask''. Необязательный одномерный массив ''vector'' должен иметь тот же тип данных, что и ''array'', причём количество элементов в ''vector'', если он задан, должно быть не меньше числа истинных элементов в ''mask''. Если ''mask'' — скаляр со значением <code>.TRUE.</code>, то число элементов в массиве ''vector'', если он задан, должно быть не меньше, чем общее число элементов в ''array''.<br>
Результатом функции будет одномерный массив того же типа, что и ''array''. Длина результата будет равна длине вектора ''vector'', если он задан; если нет — то числу истинных элементов в массиве-маске ''mask''. Если ''vector'' не задан, а ''mask'' — скаляр со значением ''истина'', то длина результирующего одномерного вектора равна числу элементов массива ''array''. <br>
Результирующий массив последовательно заполняется элементами массива ''array'' (в порядке их размещения в компьютерной памяти), удовлетворяющими истинным значениям массива ''mask''. При этом, если задан ''vector'', из него выбираются недостающие (возможно) элементы в массиве-результате, причём начиная с индекса, следующего за последним по порядку истинным элементом массива ''array''.<br>
Так, для массива <math>A=\begin{bmatrix} 0 & 1 & 0 \\ 2 & 0 & 0 \\ 0 & 0 & 3 \end{bmatrix}</math> <br>
результатом функции <code>PACK(A, mask=A.NE.0)</code> будет одномерный массив <math>\begin{bmatrix} 1 & 2 & 3 \end{bmatrix}</math>. Если дополнительно задан вектор <math>V=\begin{bmatrix} 77 & -95 & 0 & 4 & 5 & 6 & 7 & 8 & 9 & 10 \end{bmatrix}</math>, то результатом <code>PACK(A, mask=A.NE.0, V)</code> будет <br>
<math>\begin{bmatrix} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 \end{bmatrix}</math>.

=== Файлы и операции ввода-вывода ===
Фортран обладает богатым встроенным инструментарием для операций ввода-вывода, в том числе для больших массивов данных. Файлы в Фортране бывают внутренние и внешние.

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

С обоими типами файлов используются одни и те же операторы записи <code>WRITE</code> и чтения <code>READ</code>. Внутренние файлы используются для преобразований число-строка-число и для создания смешанных числовых и символьных записей.
<source lang="fortran" line="1">
Character(15) string
Real:: xyz=-123.456
Integer intg

Write(string,*) xyz            ! Запись в строку числа -123.456
Print *, 'string=', string     ! string=␣ -123.4560␣ ␣

Read (string,'(I6)') intg      ! Чтение из строки целого числа
Print *, 'intg=', intg         ! intg=␣ -123
!...
</source>

Внешние файлы подразделяются на форматные (текстовые, CR- и LF-потоки), бинарные (двоичные), непосредственно отображающие оперативную память, и неформатные (не двоичные). Кроме того, они могут быть файлами прямого и последовательного доступов с записями фиксированной и переменной длины (переменной — только для последовательных файлов), а также сегментированными записями (для очень больших неформатных последовательных файлов). Таким образом, Фортран позволяет создавать и обрабатывать довольно большое количество видов файлов — 15 способов организации.
Максимальный размер одной записи — два гигабайта.

Файлы прямого доступа позволяют осуществлять операции ввода-вывода с записями с заданным номером (без затирания вышерасположенных или нижерасположенных записей в файле).

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

=== Работа с памятью ===
В современных стандартах языка (начиная с Fortran’90 или Fortran’95) возможна работа с тремя видами ''[[Фортран#Работа с массивами|динамических массивов]]'' (автоматическими, размещаемыми и массивами-ссылками), ''[[Указатель (тип данных)|указателями]]'', ''[[Ссылка (программирование)|ссылками]]''; имеются встроенные процедуры для работы с памятью напрямую и процедуры для побитовых операций.

Стандарты языка предполагают автоматическое освобождение оперативной памяти, занятой любым типом динамического массива, после завершения работы программы или подпрограммы (процедуры, функции), даже если программистом освобождение не было выполнено явно. Это позволяет избегать возникновения [[Утечка памяти|утечек памяти]] при работе с динамическими массивами средствами Фортрана (при использовании указателей и в других случаях утечки возможны) при небрежности программирования<ref name="БартеньевСФ" />.

Автоматические массивы (размещаемые компилятором) создаются при вызове подпрограммы и являются её локальными объектами. Их границы определяются всякий раз при обращении к процедуре; при этом при выходе из неё они уничтожаются, а память — очищается. Автоматические массивы во время выполнения программы находятся в [[стек]]е, размещаемые (с помощью оператора <code>ALLOCATE</code>) — в [[Куча (память)|куче]]<ref name=":0" />.

Указатели Фортрана аналогичны указателям Си<ref name="БартеньевСФ" />, однако при решении вычислительных задач и разработке математических алгоритмов они в большинстве случаев с успехом заменяются иными инструментами Фортрана.

=== Управляющие конструкции ===
Начиная со стандарта F’90 конструкция условного перехода <code>IF THEN</code> — <code>ELSEIF THEN</code> — <code>END IF</code> не отличается от подобных конструкций в других современных языках и заменила т. н. «арифметический» <code>IF</code> с метками, признанный устаревшим<ref name=":1" />. Существует и более простая форма условного оператора: <code>IF</code><code>(''логическое'' ''условие'')</code> <code>''оператор''</code>, где исполняемый оператор должен быть единственным после оператора <code>IF</code>, например, <code>Goto</code> <code>''метка''</code>.

Конструкция выбора <code>SELECT CASE</code> — <code>CASE</code> — <code>CASE DEFAULT</code> — <code>END SELECT</code>, наоборот, отличается от конструкции <code>SWITCH</code> — <code>CASE</code> в Си-подобных языках, таких как: [[C++]]<ref>{{Cite web|url=https://msdn.microsoft.com/ru-ru/library/k0t5wee3.aspx|title=Оператор switch (C++)|publisher=msdn.microsoft.com|access-date=2016-06-05|archive-date=2016-08-13|archive-url=https://web.archive.org/web/20160813164540/https://msdn.microsoft.com/ru-ru/library/k0t5wee3.aspx|url-status=live}}</ref>, [[Java]]<ref>{{Cite web|url=https://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html|title=The switch Statement|lang=en|publisher=[[Oracle|oracle.com]]|url-status=live|access-date=2024-08-15|archive-date=2010-03-15|archive-url=https://web.archive.org/web/20100315060844/http://java.sun.com/docs/books/tutorial/java/nutsandbolts/switch.html}}</ref>, [[JavaScript]]<ref>{{Cite web|url=https://learn.javascript.ru/switch|title=Конструкция "switch"|lang=ru|url-status=live|access-date=2016-06-05|archive-date=2016-06-09|archive-url=https://web.archive.org/web/20160609052431/http://learn.javascript.ru/switch}}</ref> и других, несколько напоминая по возможностям оператор <code>CASE</code> в [[Паскаль (язык программирования)|Паскале]]<ref>{{Cite web|url=http://www.freepascal.org/docs-html/ref/refsu57.html|title=The Case statement|publisher=www.freepascal.org|access-date=2016-06-05|archive-date=2016-05-22|archive-url=https://web.archive.org/web/20160522221450/http://www.freepascal.org/docs-html/ref/refsu57.html|url-status=live}}</ref>.<syntaxhighlight lang="fortran" line="1">
Integer N(74)             ! выражение выбора — это целое, логическое, символьное выражение или
...                       ! целочисленый массив, или массив символов с любым ненулевым числом элементов 

nameSC: Select Case(N(i)) ! nameSC — имя конструкции, N(i) — элемент массива
        Case(:-5)         ! выполняется для всех N(i), меньших либо равных -5 с шагом +1
        ! Блок 1
        
        Case(-3,-1,0,2)   ! для переменной N(i), равной -3, -1, 0, 2
        ! Блок 2
        
        Case(50:100)      ! для N(i) в диапазоне от 50 до 100 включительно (шаг +1)
        ! Блок 3
        
        Case(400)         ! для N(i)=400
        ! Блок 4
        
        Case(1,20:30,35)  ! для N(i)=1, N(i) в диапазоне от 20 до 30 включительно и N(i)=35
        ! Блок 5
        
        Case Default      ! для всех прочих ситуаций. Case Default — опциональный, необязательный оператор
        ! Блок по умолчанию
        End Select nameSC
</syntaxhighlight>Если значение переменной N, называемой выражением выбора, совпадёт со списком селекторов (списком значений или диапазоном) в к-либо операторе <code>CASE</code>, например, в третьем для ''N=70'', то, после выполнения соответствующего блока операторов ''Блок-3'', происходит ''выход из конструкции'' <code>SELECT CASE</code><ref name="БартеньевСФ" /><ref name=":0" />, и операторов прерывания (типа <code>BREAK</code>) ''не требуется''. Оператор <code>CASE DEFAULT</code>, равно как и имя конструкции, не является необходимым. Диапазоны в списках селекторов различных операторов <code>CASE</code> не должны пересекаться или иметь хотя бы одного общего элемента.

В качестве выражения выбора (N) может быть элемент целочисленного массива.

Диапазоны в списках селекторов применяются только для целых или для символов, по возрастанию от нижней границы к верхней; для символов — по возрастанию [[Кодировка символов|их кодов]].

В современном Фортране существуют две формы циклов со счётчиком итераций: традиционная конструкция <code>DO</code>—<code>ENDDO</code> и цикл с меткой. Последняя признана устаревшей конструкцией начиная со стандарта F’90, однако до сих пор входит в стандарты. Для вложенных циклов с большим уровнем вложенности последняя форма может быть более лаконичной: <syntaxhighlight lang="fortran" line="1">
! Синтаксис устаревшей конструкции цикла
    do 1 k=1,10      ! 1- это метка конца цикла
      do 1 j=1,20    ! метка может быть одинаковой для вложенных циклов
        do 1 i=1,100
    arr(i,j,k)=25    
1   Continue         ! метка может стоять только перед к-либо оператором

L1: do k=1,10        ! однако современная запись допускает именовать циклы,
  L2: do j=1,20    ! что больше соответствует концепции структурного программирования
    L3: do i=1,100 ! и позволяет легче избежать ошибок 
    arr(i,j,k)=25    
    end do L3
  end do L2
end do L1
</syntaxhighlight>Заголовок цикла со счётчиком имеет следующий полный вид:<syntaxhighlight lang="fortran" line="1">
name: DO I=N1, N2, dN  ! имя конструкции необязательно
...                    ! N1 — начальное значение счётчика, N2 — конечное, dN — шаг (параметры цикла)
      END DO name      ! Параметры цикла — целые числа произвольного знака. dN не равно нулю.           

</syntaxhighlight>Число выполнения тела цикла без прерывания равно ''N<sub>с</sub>''=<code>max</code>(<code>int</code>''((N<sub>2</sub>-N<sub>1</sub>+dN)/dN), 0'') и может быть равным нулю.

Например, цикл выполнится нуль раз, если ''N<sub>2</sub><N<sub>1</sub>'' и шаг положителен: ''dN>0''. Если шаг отрицательный, ''dN<0,'' то цикл пройдёт в обратном порядке, при этом для выполнения цикла необходимо, чтобы ''N<sub>2</sub><N<sub>1</sub>''. Если шаг ''dN'' опущен, то по умолчанию он считается равным единице: ''dN=1''.

Значение переменной цикла ''I'' после выхода из него всегда равно ''N<sub>с</sub>+1'', то есть ''на единицу больше числа итераций цикла'' и не менее единицы: ''I≥1.''

Возможен также цикл с условием <code>DO WHILE</code><code>(''логическое'' ''условие'')</code> — <code>END DO</code>, и бесконечный цикл <code>DO</code> — <code>END DO</code>, имеющие стандартную форму.

Оператор <code>CYCLE</code> <code>''имя цикла''</code> прерывает ''текущую'' итерацию цикла и переходит к следующей итерации этого же цикла. Если имя цикла не указано, то выполняется прерывание итерации текущего цикла (в котором расположен оператор <code>CYCLE</code>).

Оператор <code>EXIT</code> <code>''имя цикла''</code> прерывает выполнение цикла с указанным именем и передаёт управление далее, а при отсутствии имени — прерывает текущий цикл (в который вложен оператор <code>EXIT</code>).

Операторы <code>CYCLE</code> и <code>EXIT</code> логически тождественны оператору <code>GOTO</code> (в соответствующих обстоятельствах), но существенно облегчают понимание и обслуживание кода программистом.

== Компиляторы ==
[[Файл:UCSD3.png|thumb|Экран редактора Фортрана в [[UCSD p-System]] на [[Apple II]]]]
С момента первоначальной разработки языка [[компилятор]]ы Фортрана производит фирма IBM. В настоящее время фирмой IBM поставляется оптимизирующий компилятор [[VS Fortran]]<ref>{{Cite web |url=http://www.ibm.com/software/awdtools/fortran/vsfortran/ |title=VS FORTRAN |access-date=2010-03-08 |archive-date=2021-08-09 |archive-url=https://web.archive.org/web/20210809093343/https://www.ibm.com/products/software |url-status=live }}</ref> для [[мэйнфрейм]]ов [[IBM System z]], история развития различных версий которого восходит ещё к [[1964 год]]у, а также компилятор [[XL Fortran]]<ref>{{Cite web |url=http://www.ibm.com/software/products/ru/ru/xlfortran-linux |title=XL Fortran for Linux |access-date=2010-03-08 |archive-date=2021-08-09 |archive-url=https://web.archive.org/web/20210809093358/https://www.ibm.com/products/software |url-status=live }}</ref> для платформ на базе архитектуры [[PowerPC]] — [[AIX]], [[Linux]] и суперкомпьютера [[Blue Gene]] (выпускалась также версия для [[Mac OS X]], когда компьютеры [[Macintosh]] использовали процессоры PowerPC). Оба этих компилятора содержат очень сложные оптимизаторы, являющиеся результатом непрерывной научной работы специалистов IBM на протяжении полувека. На базе компилятора IBM Fortran XL фирмой Absoft, бизнес-партнёром IBM, создан и поставляется компилятор Absoft Pro Fortran для систем на базе процессоров PowerPC (Linux, Mac OS X) и Intel (Linux, Mac OS X, Windows)<ref>{{Cite web |url=http://www.absoft.com/Absoft%20Compilers.htm |title=Absoft Pro Fortran Compiler Suites General Overview |access-date=2010-03-08 |archive-date=2021-08-09 |archive-url=https://web.archive.org/web/20210809093346/https://www.absoft.com/products/ |url-status=live }}</ref>.

Существовала реализация Фортрана для [[Виртуальная машина|виртуальной машины]] [[UCSD p-System]], которая позволяла создавать исполняемый код независимый от аппаратной платформы.

До [[1997]] крупным производителем компилятора Фортран для операционной системы Windows была корпорация [[Microsoft]]. Впоследствии она отказалась от их разработки в связи с низкой прибыльностью. После этого компилятор поставляла фирма [[Digital Equipment Corporation|DEC]], вошедшая в 1998 году в состав [[Compaq]] и вместе с последней в 2002 году слившаяся с [[Hewlett-Packard|HP]]. Дальнейшей разработкой этой версии компилятора стала заниматься фирма [[Intel]], а компилятор называется [[Intel Fortran Compiler]], который позволяет оптимизировать код под платформы Intel IA-32, x86_64 и IA-64.

Компания DEC поставляет компилятор, интегрированный в среду разработки [[Digital Visual Fortran]], основанную на [[Microsoft Visual Studio]]. Наиболее известными продуктами этой линейки являются FPS 4.0 (Microsoft Fortran Power Station), DVF 5.0 и 6.0. Каждый компилятор может поддерживать несколько стандартов Фортрана. Слияния компаний явились причиной того, что последующие продукты появлялись на рынке под торговыми марками Compaq и HP. В настоящее время HP продаёт среду разработки версии 6.6 для Intel/win32. Поддержка Фортрана реализована также для всех высокопроизводительных платформ HP.

Другим крупным поставщиком систем разработки на Фортране является фирма [[Lahey]], предлагающая интегрированные решения для Windows и Linux.

Долгое время лучшим компилятором Фортрана для PC считался компилятор фирмы [[Watcom]], который был выделен в отдельный проект [[Open Watcom]], развивающий компилятор на открытой основе.

Среди бесплатных компиляторов Фортран следует выделить компилятор от бывшей [[Sun Microsystems]] (сейчас Oracle), входящий в состав [[Sun Studio]], который генерирует эффективный код под [[SPARC]], [[x86]] и [[x86-64]]<ref>{{Cite web |url=http://developers.sun.com/sunstudio/products/benchmarks.html |title=Sun Studio — Benchmarks |access-date=2007-11-20 |archive-date=2007-10-26 |archive-url=https://web.archive.org/web/20071026005042/http://developers.sun.com/sunstudio/products/benchmarks.html |url-status=live }}</ref> и доступен для ОС [[Solaris]], [[OpenSolaris]] и [[GNU/Linux]].

Фонд свободного программного обеспечения [[GNU]] выпускал открытый компилятор Фортрана-77 [[g77]], доступный практически для любой платформы и полностью совместимый с [[GCC]]. Сейчас ему на смену пришёл компилятор [[GFortran]], в котором реализованы практически все конструкции стандарта Фортран-95 и многие конструкции стандартов Фортран-2003, Фортран-2008 и Фортран-2018. Он также полностью обратно совместим с Фортран-77. Также существует независимый проект [[g95]] по созданию на основе [[GCC]] компилятора Фортран-95.

== Взаимодействие с другими языками ==
Многие системы программирования позволяют компоновать полученные в результате трансляции фортрановской программы [[объектный файл|объектные файлы]] с объектными файлами, полученными от компиляторов с других языков, что позволяет создавать более гибкие и многофункциональные приложения. Для языка Фортран также доступно большое количество библиотек, содержащих как подпрограммы решения классических вычислительных задач ([[LAPACK]], [[IMSL]], [[BLAS]]), задач организации распределённых вычислений ([[Message Passing Interface|MPI]], [[PVM]]), так и задач построения графических интерфейсов ([[Quickwin]], [[FORTRAN/TK]]) или доступа к [[СУБД]] ([[Oracle (СУБД)|Oracle]]).

== Фортран в СССР ==
Фортран в [[СССР]] появился позже, чем на Западе, поскольку поначалу в СССР более перспективным языком считался [[Алгол]]. Во внедрении Фортрана большую роль сыграло общение советских физиков со своими коллегами из [[CERN]], где в 1960-х годах почти все расчёты велись с использованием программ на Фортране<ref>{{Cite web |url=http://samlib.ru/r/rastorguew_a_a/fortran.shtml |title=Очерк Александра Расторгуева о появлении Фортрана в Дубне |access-date=2012-01-22 |archive-date=2014-07-10 |archive-url=https://web.archive.org/web/20140710010357/http://samlib.ru/r/rastorguew_a_a/fortran.shtml |url-status=live }}</ref>.

Первый советский [[компилятор]] с Фортрана был создан в 1967 году для машины [[Минск (компьютер)|Минск-2]], однако он не получил большой известности. Широкое внедрение Фортрана началось после создания в 1968 году компилятора ФОРТРАН-ДУБНА для машины [[БЭСМ-6]]. Фортран — основной язык для [[АСВТ]] и [[СМ ЭВМ]], часто использовался вместе с [[препроцессор]]ом [[РАТФОР]]. Машины [[ЕС ЭВМ]], появившиеся в [[1972 год]]у, уже изначально имели [[транслятор]] Фортрана («позаимствованный» с [[IBM/360]] вместе с другим программным обеспечением).

В 1970-x годах в [[ИПМ РАН|ИПМ]] была разработана графическая библиотека [[Графор|ГРАФОР]] («Графическое РАсширение ФОРтрана»)<ref>{{Cite web |url=http://www.graphicon.ru/ru/russia/history |title=История компьютерной графики в России |access-date=2012-01-08 |archive-url=https://web.archive.org/web/20120317205453/http://graphicon.ru/ru/russia/history |archive-date=2012-03-17 |url-status=dead }}</ref>.

В конце 1980-х — начале 1990-х физик [[Зарецкий, Андрей Владленович|Андрей Зарецкий]] создал серию детских книжек, одним из главных героев которых был [[Энциклопедия профессора Фортрана|профессор Фортран]], доступным языком объяснявший детям основы [[Компьютерная грамотность|компьютерной грамотности]] и программирования<ref>{{cite news |title=Энциклопедия профессора Фортрана |url=http://www.sutki.net/culture/17088-entsiklopediya_professora_fortrana.html |work=Sutki.net |date=2008-01-29 |access-date=2013-06-11 |archive-url=https://web.archive.org/web/20120310055828/http://www.sutki.net/culture/17088-entsiklopediya_professora_fortrana.html|archive-date=2012-03-10}}</ref><ref>{{cite news |first=Александр |last=Кириленко |title=Эстония вводит программирование в школах начиная с младших классов |url=http://noos.com.ua/ru/post/2984 |work=Ноосфера |date=2009-09-07 |access-date=2013-06-11 |archive-url=https://web.archive.org/web/20120909193515/http://www.noos.com.ua/ru/post/2984 |archive-date=2012-09-09}}</ref>.

== Примечания ==
{{примечания}}

== Литература ==
* Программирование, отладка и решение задач на ЭВМ единой серии. Язык Фортран: для вузов / под ред. И. А. Кудряшова. Л., Энергоатомиздат, 1988 - 203 стр.
* {{книга |заглавие=Fortran. Programmer's Reference Manual. The Fortran Automatic Coding System for the IBM 704 EDPM |ссылка=http://bitsavers.informatik.uni-stuttgart.de/pdf/ibm/704/704_FortranProgRefMan_Oct56.pdf |год=1956 |издательство=IBM Corp. |страниц=51}}
* {{книга
|автор=Роберт У. Себеста.
|часть=2.3. Компьютер IBM 704 и язык Фортран
|заглавие=Основные концепции языков программирования
|ссылка=https://archive.org/details/libgen_00052588
|оригинал=Concepts of Programming Languages
|ответственный=Пер. с англ
|издание=5-е изд
|место=М.|издательство=[[Вильямс (издательство)|Вильямс]]
|год=2001
|страницы=[https://archive.org/details/libgen_00052588/page/n63 63]—69
|страниц=672
|isbn=5-8459-0192-8 (рус.), ISBN 0-201-75295-6 (англ.)
|тираж=5000
}}
* [http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=50459 ISO/IEC 1539-1:2010 Information technology — Programming languages — Fortran — Part 1: Base language]
* [http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=26934 ISO/IEC 1539-2:2000 Information technology — Programming languages — Fortran — Part 2: Varying length character strings]

== Ссылки ==
{{Навигация}}
* [https://web.archive.org/web/20071125181109/http://www.visual.2000.ru/develop/fortran/index.htm О старом Фортране замолвлено слово…]
* [http://rsusu1.rnd.runnet.ru/develop/fortran/prof77/prof77.html Professional Programmer’s Guide to Fortran77]{{ref|en}}
* [http://gcc.gnu.org/fortran/ gfortran] — Компилятор Фортрана 95/2003/2008, часть [[GNU Compiler Collection|Коллекции компиляторов GNU]]{{ref|en}}
* [http://progopedia.ru/language/fortran/ Статья Фортран] в [[Прогопедия|Прогопедии]] — энциклопедии языков программирования{{ref|ru}}

{{ВС}}

[[Категория:Фортран| ]]
[[Категория:Объектно-ориентированные языки программирования]]
[[Категория:Языки программирования по алфавиту]]
[[Категория:Статьи с примерами кода на Фортране]]