FORTRAN е сред първите езици за програмиране от високо ниво. Името FORTRAN – (идва от FORmula TRANslator или „преводач на формули“, и до версия FORTRAN 77 се е изписвало с главни букви) – подсказва предназначението му за програмиране на изчислителни процеси. С времето езикът се усъвършенства и се превръща в универсален.

С FORTRAN се въвеждат основните техники за програмиране, останали непроменени до наши дни. Може да се каже, че той е базата за съвременните обектно ориентирани езици. Преди създаването му, програмирането е било много трудно и компютрите е трябвало да бъдат щателно кодирани „ръчно“.

С FORTRAN започва процесът по отделянето на софтуера от хардуера, на който програмите се изпълняват. Ако преди това броят на инструкциите, въвеждани „на ръка“, за да изпълни компютърът дадена програма, е бил 1000, с FORTRAN това число се редуцира до едва 47.

Макар че възниква и се развива като процедурен език за програмиране, в най-новата си версия FORTRAN е обектно ориентиран език. За FORTRAN е създаден и първият компилатор, определян като крайъгълен камък в историята на компютърното програмиране.

История и исторически факти

Историята на FORTRAN тръгва от компанията IBM. Целта била да се създаде компилируем език с оператори и функции, максимално приближени към речевите конструкции и алгебричните изрази.

В края на 1953 година Джон Бакус – създателят на FORTRAN, предлага на работодателите си от IBM алтернатива на процедурното програмиране, която да намери приложение при разработвания по това време IBM 704 мейнфрейм компютър – мощна за времето си машина, предназначена за обработката на големи масиви от данни.

В историческия екип на Бакус, работил за създаването на FORTRAN, имало инженери, криптограф, майстор по шахмат, програмисти и математици – какъвто е бил и самият Джон Бакус. В екипа влизат Робърт Голдбърг, Шелдън Бест, Харлан Херик, Питър Шеридън, Рой Нът, Робърт Нилсън, Ървинг Зилер, Лоис Хейбт и Дейвид Сеър. „Ние бяхме хакерите на онова време.“ – това са думи на Ричард Голдбърг – също математик, и участник в екипа от създатели на FORTRAN.

През 1954 година екипът започва работата по FORTRAN, а през 1957 година крайният продукт е завършен и е пуснат за търговско разпространение.

Джон Бакус, създателят на програмния език FORTRAN

Докато обществото е скептично, че този нов начин за програмиране е по-добър от „ръчното“ кодиране на компютрите, FORTRAN намалява програмиращите изрази, нужни на компютъра, за да работи, до 20. С това FORTRAN бързо печели общественото одобрение. В свое интервю за ведомственото списание на IBM от 1979 година Джон Бакус казва за себе си: „Повечето ми успехи са дошли заради мързела ми. Не харесвах писането на програмите, затова, когато работих върху IBM 701 и пишех програми за изчисляване на траекториите на снаряди, аз реших да създам система, която улеснява писането на компютърни програми.“ Бакус умира през 2007 година в САЩ, на 82 години.

FORTRAN среща широкото одобрение на научната общност, и това стимулира екипа да създаде компилатори, генериращи още по-бързи и ефективни програми. А интегрирането на сложните числови типове данни във FORTRAN прави езика особено подходящ за писането на технически приложения, например в областта на електроинженерството.

Ръководните кадри от различни бизнес-сектори бързо осъзнават значението на FORTRAN, най-вече заради възможностите му да подобрява производителността като намалява времето и усилията, необходими за писането на специфични програмни приложения. Банките започват да използват FORTRAN за създаването на мощни изчислителни програми, които да пресмятат риска, докато осигурителните компании го използват за актюерски оценки. И тъй като компютърните фирми внедряват компилатори за FORTRAN на машините си, използвайки стандарта на IBM, FORTRAN e език за кръстосани платформи още от самото си начало.

До 1960 година с версии на FORTRAN работят компютрите IBM 709, 650, 1620, и 7090. Всъщност, нарастващата популярност на FORTRAN стимулира конкуриращите се производители на компютри да внедряват компилатори за FORTRAN в техните машини. Така, до 1963 година вече съществуват над 40 компилатора за FORTRAN. FORTRAN се превръща в първия широко използван програмен език, приет от разнородната общност на компютърните разработчици.

В наши дни, повече от 50 години след дебюта си, Fortran или първият компютърен език от високо ниво, продължава да се използва ежедневно. Намира приложение при изготвянето на метеорологичните прогнози с Доплеров радар, проучванията на атмосферата и океана, както и при симулациите с наночастици, изследванията на генома, ДНК и атомните структури. Fortran намира приложение и във фермерството, като с негова помощ се подбират най-добрите породи пилета, на базата на генетичната селекция.

FORTRAN 77

PROGRAM HELLOW
 PRINT '(A)', 'Hello, world'
 STOP
END

Fortran 90

program HelloWorld
  write (*,*) 'Hello, world!' ! This is an inline comment
end program HelloWorld

Версии на езика FORTRAN

FORTRAN I

Първият компилатор за FORTRAN играе ключова роля в историята на програмирането. По това време компютрите са имали малка памет (около 15KB, често капацитетът на паметта се е броял в битове), били са бавни, с примитивна операционна система. Изглеждало е най-практично да се програмира на асемблерен език.

Първият FORTRAN компилатор е създаден през 1957 година от програмистите на IBM, ръководени от Джон В. Бакус. Нищо чудно, че езикът се е използвал много по това време – програмирането за изчисляването на мощността на ядрен реактор вече отнемало часове вместо седмици, и изисквало по-малко умения за програмиране. Още едно предимство на езика било, че програмите станали преносими. FORTRAN победил в битката срещу асемблерните езици и се използвал от научни и военни общности.

FORTRAN II (1958)

Във FORTRAN II са направени значителни подобрения. Главната цел била да се поддържа процедурното програмиране, като се разрешава на потребителя да пише подпрограми и функции, които връщат стойности, с параметри, преминали референция. Добавена е способността за разделно компилиране на програмни модули, и модулите на асемблерен език можели да бъдат linked loaded с модулите FORTRAN. Към FORTRAN II са добавени шест нови инструкции :

SUBROUTINE, FUNCTION и END;
CALL и RETURN;
COMMON.

През следващите няколко години към FORTRAN II е добавена поддръжка за DOUBLE PRECISION и COMPLEX типове данни.

Ранните FORTRAN компилатори са поддържали подпрограмите без рекурсия.

FORTRAN III (1958)

FORTRAN III никога не е бил разпространяван публично. При него е било възможно използването на асемблерен код по средата на FORTRAN кода.

Както при FORTRAN за IBM 704 и FORTRAN II, и при FORTRAN III съществува зависимост от машината, на която се използва. Това прави писания на FORTRAN код непреносим от един на друг компютър. Ранните версии на FORTRAN, обезпечени от други търговски компании, са имали същия недостатък.

FORTRAN IV (1961)

FORTRAN IV е подобрена версия на FORTRAN II. Част от подобренията са допълнените инструкции COMMON и EQUIVALENCE, отстранени са някои неизправности. Транслаторът от FORTRAN II към FORTRAN IV е използван за запазване на съвместимостта с ранните FORTRAN програми. През месец май 1962 година Американската асоциация по стандартизация започва разработка на стандартен език FORTRAN. Това се оказва важна стъпка за развитието на езика, и компаниите започват да внедряват системи за FORTRAN при всеки нов компютър.

FORTRAN 66 (1972)

Може би най-значимото събитие в ранната история на FORTRAN е решението на Американската Асоциация по Стандартизация (ASA) да се сформира комисия, финансирана от BEMA (Bussiness Equipment Manufacturers Association), която да създаде American Standard Fortran, или универсален стандарт за FORTRAN., тъй като версиите на FORTRAN за различни компилатори можело да са различни. Като резултат, през 1966 година са одобрени два стандарта и се очертават два езика: FORTRAN (базиран на FORTRAN IV) и Basic FORTRAN (базиран на FORTRAN II). FORTRAN, определен по първия стандарт, официално обозначен X3.9.1966, става популярен като FORTRAN 66. Той включва:

Subroutine, Function and Block Data;
INTEGER, REAL, DOUBLE PRECISION, COMPLEX и LOGICAL data types;
COMMON, DIMENSION и EQUIVALENCE изрази;
DATA израз;
Функции Intrinsic и EXTERNAL;
GO TO;
Логическо IF и аритметичен IF израз;
Цикъл DO;
READ, WRITE, BACKSPACE, REWIND и ENDFILE изрази;
FORMAT;
CALL, RETURN, PAUSE и STOP;
Линии за коментари;
END.

FORTRAN 77 (1980)

След пускането на стандарта FORTRAN 66 търговските компании представят няколко разширения на Standard FORTRAN, с което подтикват Американския Национален Институт по Стандартизация (ANSI) през 1969 година да започне работа по ревизирането на стандарта от 1966 година, с подкрепата на CBEMA (Computer Business Equipment Manufacturers Association, предишната BEMA). Финалният проект на този ревизиран стандарт е разпространен през 1977 година и води до формалното одобряване на новия FORTRAN стандарт през април 1978 година. Новият стандарт, наречен FORTRAN 77 и официално обозначен като X3.9 – 1978, идва с някои значителни изменения, кореспондиращи със слабите места на FORTRAN 66, като :

Блок IF и END IF изрази с избираеми ELSE и ELSE IF параграфи, които трябва да осъществят по-доброто езиково осигуряване на структурното програмиране;
Разширен цикъл DO, включващ параметри, изрази, и други;
Open, Close и INQUIRE изрази за подобрени I/O възможности;
Директен достъп до I/O файлове;
Инструкцията IMPLICIT;
Данни от тип CHARACTER;
PARAMETER израз за определяне на константи;
Израз SAVE.

Пример: PROGRAM HELLOW

PRINT '(A)', 'Hello, world'

STOP

END

FORTRAN 90 (1991)

Дълго забавилият се наследник на FORTRAN 77, наричан неофициално Fortran 90, е разпространен като ISO/IEC стандарт през 1991 година, като и ANSI Стандарт през 1992 година. Наречен е Fortran 90 (вече изписван с малки букви). Той е подобрена версия на FORTRAN 77, с много добавени инструменти.

Във Fortran 90 са добавени:

Свободен формат на изходния код, с ключови думи на Fortran, изписвани също с малки букви;
Идентифицира до 31 символа (в предишната версия е можело само до 6 символа);
Вътрешни коментари;
Процедури RECURSIVE;
Модерен контрол на структурите (CASE & DO WHILE);
Регистри/Структури – наречени „Delivered Data Types“;
Система за операции с масиви;
Динамично разпределяне на паметта;
Оператор за претоварване;
Модули – пакети, съдържащи променливи и кодове.

Пример: program HelloWorld

  write (*,*) 'Hello, world!' ! This is an inline comment

end program HelloWorld

Fortran 95 (1997)

Fortran 95 официално излиза като ISO/IEC 1539 – 1:1997 и е с минимални подобрения. Коригирани са някои недостатъци на Fortran 90. Все пак, във Fortran 95 са добавени няколко разширения от спецификацията на High Performance Fortran (HPF) като:

Конструкции FORALL и гнездото WHERE, подпомагащо векторизацията;
Процедури PURE и ELEMENTAL;
Инициализация по подразбиране на получения тип компоненти;
По-голяма възможност за използване на изрази, инициализиращи обекти;

Разширен е наборът от съществени функции (например аргументът „dim“ е добавен към „maxloc“).

Няколко функции, регистрирани като „отпадащи от употреба“ още във Fortran 90, са премахнати от Fortran 95:

Изразите DO, използващи REAL и DOUBLE PRESICION променливи;
Инструкция PAUSE;
ASSIGN и определената инструкция GO TO;

Езикът Fortran 95 също включва два избираеми модула:

Varying character strings (ISO/IEC 1539 – 2 : 2000);
Conditional compilation (ISO/IEC 1539 – 3 : 1998).

Те заедно формират International Standard (ISO/IEC 1539).

Fortran 2003 (2004)

Fortran 2003, официално издаден като ISO/IEC 1539 – 1:2004, е версия, въвеждаща много нови подобрения. Част от тях са:

Подобрен контрол на достъпността подобрени структурни конструктори, и други;
Инструкцията FLUSH, достъп до съобщенията за грешка, и други;
Поддържа IEEE floating-point arithmetic и floating point exception handling;
Съвместим с програмния език C;

Fortran 2008 (2010)

Последната излязла версия на езика е ISO/IEC 1539 – 1:2010, неформално известна като Fortran 2008. Тя е одобрена през септември 2010 година. Както при Fortran 95, това е минимално надграждане, обединяване, избистряне и корекция на предходната версия Fortran 2003. Част от новите възможности, които дава версията, са : Подмодули – допълнителни структуриращи улеснения за модулите; заместват ISO/IEC TR 19767:2005;

Coarray Fortran – паралелно изпълняващ модул;
Конструкторът DO CONCURRENT – за повтарящи се цикли, без взаимозависимост;
Атрибутът CONTIGUOUS – уточнява мястото за съхранение на рестрикциите;
Конструкторът BLOCK – може да съдържа декларации на обекти с конструктивна възможност;
Рекурсия при въвеждане на данни – като алтернатива за рекурсивни поинтъри в получените типове.

Важно приложение към Fortran 2008 е Техническата спецификация на ISO (TS) 29113 за Допълнителна оперативна съвместимост на Fortran с езика C, която през май 2012 е предаденя на ISO за одобрение. Спецификацията подпомага достъпа до array дескриптора от езика C и позволява игнорирането на тип или ранк от аргументи.

Компилатори

GFortran – разни операционни системи
Sun Studio – Solaris, OpenSolaris, Linux

Характеристики и синтаксис на езика

FORTRAN
	FORTRAN
	Перфокарта за FORTRAN
Парадигма	процедурен, императивен, структурен, обектно ориентиран
Реализиране през	1957
Автор	Джон Бакус
Типизация на данните	статична, силна
Повлиява	ALGOL 58, PL/I
Уебсайт	www.fortran.com
	FORTRAN в Общомедия

Типове данни

Във FORTRAN се използват пет основни типа данни :

Целочислен тип

Може да съдържа само цели числа

Пример – 1, 2, 3, ..., n

program testInt
    implicit None
    integer::largeval
    print *, huge(largeval)
end program testInt

Резултатът от показаното парче код ще е 2147483647.

Забележка: Методът huge() ще даде най-голямото число което може да държи определен тип.

Също така могат да се конкретизират байтовете на числото, използвайки kind спецификатора.

program testInt
implicit none

   !two byte integer
   integer(kind=2) :: shortval

   !four byte integer
   integer(kind=4) :: longval

   !eight byte integer
   integer(kind=8) :: verylongval

   !sixteen byte integer
   integer(kind=16) :: veryverylongval

   !default integer
   integer :: defval

   print *, huge(shortval)
   print *, huge(longval)
   print *, huge(verylongval)
   print *, huge(veryverylongval)
   print *, huge(defval)

end program testInt

Резултатът от показаното парче код ще е:

32767

2147483647

9223372036854775807

170141183460469231731687303715884105727

2147483647.

Реален тип

Това е тип с плаваща запетая 0.111, 3.14, 5.68. Традиционно, има два различни реални типа – обикновеният реален тип и двойно прецизният тип. Fortran 90/95 осигурява повече контрол над прецизността на реалните и целочислените типове чрез kind спецификатора.

program division
    implicit none
    real :: p, q, realRes
    integer :: i, j, intRes
    p = 2.0
    q = 3.0
    i = 2
    j = 3
    realRes = p/q
    intRes = i/j
    print *, realRes
    print *, intRes
end program division

Резултатът от показаното парче код ще е:

0.666666687

0.

Комплексен тип

Този тип се използва за запазването на комплексни числа.

Комплексното число има две части – реална част и имагинерна част. Две последователни числови единици за съхранение(памет) запазват тези две части. Комплексното число (3.0, -5.0) е равно на 3.0 – 5.0i. Основната функция за създаването на комплексно число е cmplx(). Резултатът се състои от реална и имагинерна част, всяка с нейната си прецизност, независимо от типа на входните данни.

program createComplex
   implicit none
   integer :: i = 10
   real :: x = 5.17
   print *, cmplx(i, x)
end program createComplex

Резултатът от показаното парче код ще е:

(10.0000000, 5.17000008).

Следващите редове демонстрират аритметика с комплексни числа:

program ComplexArithmatic
implicit none

   complex, parameter :: i = (0, 1)   ! sqrt(-1)
   complex :: x, y, z

   x = (7, 8);
   y = (5, -7)
   write(*,*) i * x * y

   z = x + y
   print *, "z = x + y = ", z

   z = x – y
   print *, "z = x – y = ", z

   z = x * y
   print *, "z = x * y = ", z

   z = x / y
   print *, "z = x / y = ", z

end program ComplexArithmatic

Резултатът от показаното парче код ще е:

(9.00000000, 91.0000000)

z = x + y = (12.0000000, 1.00000000)

z = x – y = (2.00000000, 15.0000000)

z = x * y = (91.0000000, -9.00000000)

z = x / y = (-0.283783793, 1.20270276)

Логически тип

Има само два вида логически типове .true и .false.

Символен тип

Той е предназначен за запазването на символи и символни низове. Дължината на символния низ може да се зададе чрез len спецификатора. Ако не е зададена стойност, той е 1.

character (len=40) :: name
name = “Zara Ali”

Функцията name(1:4) би дал изрязаният низ „Zara“.

Оператори

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

- Аритметични оператори

- Релационни оператори

- Логически оператори.

Аритметични оператори

Следващата таблица показва всички аритметични оператори, които поддържа Fortran:

A = 5 и B = 3;

Оператор	Описание	Пример
+	Събира два операнда.	A + B ще даде 8
-	Изважда от първия операнд втория.	A – B ще даде 2
*	Умножава двата операнда.	A * B ще даде 15
/	Разделя първия на втория операнд.	A / B ще даде 1
**	Повдига първия операнд на степен втори операнд.	A ** B ще даде 125

Релационни оператори

Следващата таблица показва релационните оператори поддържани от Fortran.

A = 10, B = 20;

Оператор	Еквивалент	Описание	Пример
==	.eq.	Проверява дали двата операнда са равни.	(A == B) невярно
/=	.ne.	Проверява дали двата операнда са различни.	(A != B) вярно
>	.gt.	Проверява дали първият операнд е по-голям от втория.	(A > B) невярно
<	.lt.	Проверява дали първият операнд е по-малък от втория.	(A < B) вярно
>=	.ge.	Проверява дали първият операнд е по-голям или равен на втория.	(A >= B) невярно
<=	.le.	Проверява дали първият операнд е по-малък или равен на втория.	(A <= B) вярно

Логически оператори

Логическите оператори във Fortran работят само с логически стойности true или false

Следващата таблица показва всички логически оператори, поддържани от Fortran.

A = true, B = false;

Оператор	Описание	Пример
.and.	Логическо И – трябва и двата операнда да са true, за да върне true.	(A .and. B) false
.or.	Трябва поне единият операнд да е true, за да върне true.	(A .or. B) true
.not.	Логическо отрицание, служи за обръщане на логиката.	!(A .and. B) вярно
.eqv.	Логически ЕКВИВАЛЕНТ, служи за проверка на еквивалентността на двата оператора.	(A .eqv. B) невярно
.neqv.	Логически НЕ-ЕКВИВАЛЕНТЕН оператор, служи за проверка на не-еквивалентността на двата операнда.	(A .neqv. B) невярно

Променливи

Променливата не е нищо друго, освен име, дадено на паметта за съхранение, за да може нашата програма да манипулира. Всяка променлива трябва да си има ТИП, който определя размера и разположението на паметта.

Името на променливатя може да съдържа букви, цифри и знака „_“. Имената във Fortran трябва да се подчиняват на следните правила:

Не могат да бъдат по-големи от 31 знака;
Името трябва да съдържа само букви, цифри (0 – 9) знака „_“;
Първият знак трябва да бъде буква;
Имената са чувствителни към малки и големи букви.

Променливите се декларират в началото на програмата или подпрограмата.

integer :: total
real :: average
complex :: cx
logical :: done
character(len=80) :: message ! a string of 80 characters

Инициализиране на стойности:

total = 20000
average = 1666.67
done = .true.
message = “Hello World from team Grapefruit Sofrtware University – Sofia”
cx = (3.0, 5.0) ! cx = 3.0 + 5.0i

Може да се използва същата функция cx за инициализацията на комплексни стойности:

cx = cmplx (1.0/2.0, -7.0) ! cx = 0.5 – 7.0i
cx = cmplx (x, y) ! cx = x + yi

Следващият пример демонстрира декларацията на променлива, инициализацията и изкарването ѝ на конзолата:

program variableTesting
implicit none

   ! declaring variables
   integer :: total
   real :: average
   complex :: cx
   logical :: done
   character(len=80) :: message ! a string of 80 characters

   !assigning values
   total = 20000
   average = 1666.67
   done = .true.
   message = "Hello World from team Grapefruit Software University – Sofia "
   cx = (3.0, 5.0) ! cx = 3.0 + 5.0i

   Print *, total
   Print *, average
   Print *, cx
   Print *, done
   Print *, message

end program variableTesting

Когато по-горният код се изпълни, на конзолата ще се изпише:

20000

1666.67004

(3.00000000, 5.00000000)

T

Hello World from team Grapefruit Software University – Sofia

Константи

Константите са фиксирани стойности, които програмата не може да променя по време на изпълнението. Тези фиксирани стойности се наричат още литерали.

Константите могат да бъдат от всеки от основните типове данни като: integer, floating, character, complex или string.

Има само две логически стойности за константи – .true. или .false.

Константите се използват също като регулярните променливи, с изключение на това, че не могат да променят стойностите си.

Именувани константи и литерали

Има два типа константи:

Литерал константи
Именувани константи

Литерал константи

Литерал константите имат стойност, но нямат име.

Пример:

Тип	Пример
Integer константи	0 1 -1 300 123456789
Real константи	0.0 1.0 -1.0 123.456 7.1E+10 -52.715E-30
Complex константи	(0.0, 0.0) (-123.456E+30, 987.654E-29)
Logical константи	.true. .false.
Character константи	„PQR“ „a“ „123'abc$%#@!“ " a quote "" „ 'PQR' 'a' '123“abc$%#@!' ' an apostrophe '' '

Именувани константи

Именуваните константи имат име и стойност. Именуваните константи трябва да се декларират в началото на програмата или процедурата, също като при декларация на тип променлива. Именуваните константи се декларират с атрибута parameter.

real, parameter :: pi = 3.1415927

Следната програма изчислява изместване, поради вертикално движение под действието на гравитацията.

program gravitationalDisp
! this program calculates vertical motion under gravity
implicit none

   ! gravitational acceleration
   real, parameter :: g = 9.81

   ! variable declaration
   real :: s ! displacement
   real :: t ! time
   real :: u ! initial speed

   ! assigning values
   t = 5.0
   u = 50

   ! displacement
   s = u * t – g * (t**2) / 2

   ! output
   print *, "Time = ", t
   print *, 'Displacement = ',s

end program gravitationalDisp

След компилация на кода резултатът ще бъде:

Time = 5.00000000

Displacement = 127.374992.

Функции и подпрограми

При писане на голяма програма е удобно в нея да се отделят често използваните повтарящи се структури. За целта езикът FORTRAN позволява програмата да се състои от главна програма, от която се извикват съответните подпрограми. Съществуват няколко типа подпрограми: стандартни функции (SQRT,COS и т.н.), външни функции (FUNCTION), подпрограми от типа SUBROUTINE. Подпрограмите FUNCTION връщат стойност, докато тези от типа SUBROUTINE връщат няколко резултата.

Главната програма започва с инструкцията PROGRAM name, където name е името на програмата, и завършва с END. Между тези две инструкции се разполага тялото на главната програма и извикванията на подпрограмите.

FUNCTION

Function подпрограмите имат една-единствена цел – да приемат аргументи, да извършат манипулации, и да върнат само един резултат. Във FORTRAN има над 40 вградени написани подпрограми, които са базирани основно на математически функции.

print *, ABS (T)
y = SIN (X) + 45
m = MAX(a,b,c,d)
c = SQRT (a* * 2 +b* * 2)

Както се вижда от примера фунцкиите могат да приемат един, два или повече аргумента, също могат да приемат изрази и константи. Function подпрограмите, които се пишат от програмиста, имат следния синтаксис:

type FUNCTION function-name (arg1, arg2, ..., argn)
IMPLICIT NONE
    [specification part]
    [execution part]
    [subprogram part]
END FUNCTION function-name

type – типът, който задаваме на подпрограмата да върне;

function-name – името на фунцкията(подпрограмата);

arg1, ...,argn – аргументите, които приема функцията;

За да използваме Function подпрограмите трябва да следваме някои правила

Function подпрограмите трябва да са написани след END състоянието на главната програма.
На първия ред трябва да имат типа, който ще връщат, името на функцията и аргументите, които ще приема.
Променливите които функцията ще използва, трябва да се декларират в обхвата на функцията които е между първия ред и END реда, и преди да се използват
Преди RETURN трябва да приравним името на функцията на израза, който искаме тя да върне; така компилаторът разбира коя стойност да върне обратно в основната програма.
Функцията трябва да завърши с RETURN, последвано от END.
В основната програма трябва да декларираме функцията заедно с типа, който тя връща.

function-name = expression

PROGRAM FUNDEM
    !Declarations for main program
    real A,B,C
    real AV, AVSQ1, AVSQ2
    real AVRAGE
    !Enter the data
    data A,B,C/5.0,2.0,3.0/

    !Calculate the average of the numbers
    AV = AVRAGE(A,B,C)
    AVSQ1 = AVRAGE(A,B,C) **2
    AVSQ2 = AVRAGE(A**2,B**2,C**2)

    print *,'Statistical Analysis'
    print *,'The average of the numbers is:',AV
    print *,'The average squared of the numbers: ',AVSQl
    print *,'The average of the squares is: ', AVSQ2
END

real FUNCTION AVRAGE(X,Y,Z)
    real X,Y,Z,SUM
    SUM = X + Y + Z
    AVRAGE = SUM /3.0
    RETURN
END

SUBROUTINE

SUBROUTINE подпрограмите, за разлика от функциите, връщат няколко резултата; в основния метод се извикват с CALL, вход, името на метода, изход и след тях скоби, в които се намират аргументите. Входът и изходът са съответно това, което функцията приема и връща. Подобно на Function подпрограмите накрая се завършва с RETURN.

PROGRAM SUBDEM
    real A,B,C,SUM,SUMSQ
    CALL INPUT(+ A,B,C)
   	CALL CALC(A,B,C,SUM,SUMSQ)
   	CALL OUTPUT(SUM,SUMSQ)
END

SUBROUTINE INPUT(X, Y, Z)
   	real X,Y,Z
   	print *,'ENTER THREE NUMBERS => '
 	READ *,X,Y,Z
 	RETURN
END

SUBROUTINE CALC(A,B,C, SUM,SUMSQ)
   	real A,B,C,SUM,SUMSQ
   	SUM = A + B + C
   	SUMSQ = SUM **2
   	RETURN
END

SUBROUTINE OUTPUT(SUM,SUMSQ)
   	real SUM, SUMSQ
   	print *,'The sum of the numbers you entered are: ',SUM
   	print *,'And the square of the sum is:',SUMSQ
END

За да използваме SUBROUTINE подпрограмите, също като при FUNCTION подпрограмите, трябва да спазваме някои правила

Не е нужно да ги декларираме в главната програма както се прави с FUNCTION подпрограмите.
Започват с думата SUBROUTINE, името на функцията и аргументите, които тя приема.

Добра практика е, за да можем да разграничим коя функция е за входните данни, коя е основна и коя е за изходните данни – да ги разделяме с нов ред.

FORTRAN и суперкомпютрите

През 1968 година в статия от печата създателите на BASIC определят Fortran като „старомоден“. Тъй като Fortran е използван в продължение на много десетилетия, той е широко разпространен сред научните и инженерни общности. Jay Pasachoff пише през 1984 година, че студентите по физика и астрономия трябва да научат Fortran, защото езикът е толкова разпространен, че изглежда малко вероятно учените да преминат на Pascal, Modula-2 или някои други.

През 1993 година Cecil E. Leith нарича Fortran „майчин език на научните изчисления“ и добавя, че замяната му с друг език може и да не се случи. Това е основният език за някои от най-интензивните задачи на супер-компютърните изчисления, в области като астрономия, метеорология, линейна алгебра (LAPACK), цифрови библиотеки, строително инженерство, хидроложко моделиране и оптимизиране, сателитна симулация и анализ на данни, и други.

От края на 90-те години най-използваните библиотеки за софтуер се пишат на C, и по-често на C++. Логично, все по-голяма част от научния код също се пише на тези програмни езици. Поради тази причина, към Fortran 2003 са прибавени инструменти за синхронизация със C, и са подсилени с ISO / IEC техническа спецификация 29113, която ще бъде внедрена във Fortran 2015.

Езици, базирани на FORTRAN

Преди Fortran 77, редица препроцесори били използвани главно, за да направят езика по-достъпен, и с идеята, че кодът може да бъде компилиран на всяка машина със стандартен FORTRAN компилатор. Препроцесорите обикновено поддържали структурно програмиране, имена на променливи, по-дълги от шест знака, допълнителни типове данни, условно компилиране, и други.

Популярните препроцесори включвали FLECS, iftran, MORTRAN, SFtran, S-Fortran, Ratfor, и Ratfiv. Ratfor и Ratfiv, например, използвали наподобяващ C език, който извеждал обработения предварително код в стандарта FORTRAN 66.

Независимо от предимствата на Fortran, препроцесорите продължат да се използват за условно компилиране.

Една от най-ранните версии на FORTRAN, въведена през 60-те години, се ползвала с популярност в колежи и университети. Разработеният, поддържан и разпространяван от Университета на Ватерло програмен език WATFOR се основава до голяма степен на FORTRAN IV. WATFOR е наследен от WATFIV и неговите по-късни версии.

Стандартът Fortran 95 включва опционална част 3, която дава възможност за условна компилация. Тази опция често е наричана „CoCo“.

Много компилатори за Fortran разполагат с интегрирани в своите системи подгрупи на C-препроцесора.

SIMSCRIPT е специфичен препроцесор за Fortran за моделиране и симулиране на големи, разнородни системи.

Езикът за програмиране F е проектиран като подразделение на Fortran 95, което трябвало да премахне излишните, неструктурирани и стари функции на Fortran, като изразът EQUIVALENCE например. F е описан от създателите си като „компилируем, структуриран език за програмиране, особено подходящ за образование и научни изчисления“.

В партньорство Lahey и Fujitsu успяха да създадат Fortran за Microsoft .NET Framework. Продуктът Silverfrost FTN95 осигурява възможността за писане на .NET код.

Източници

www-03.ibm.com
www.phys.uni-sofia.bg Архив на оригинала от 2016-06-05 в Wayback Machine.

Тази страница частично или изцяло представлява превод на страницата Fortran в Уикипедия на английски. Оригиналният текст, както и този превод, са защитени от Лиценза „Криейтив Комънс – Признание – Споделяне на споделеното“, а за съдържание, създадено преди юни 2009 година – от Лиценза за свободна документация на ГНУ. Прегледайте историята на редакциите на оригиналната страница, както и на преводната страница, за да видите списъка на съавторите.

ВАЖНО: Този шаблон се отнася единствено до авторските права върху съдържанието на статията. Добавянето му не отменя изискването да се посочват конкретни източници на твърденията, които да бъдат благонадеждни.