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

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 намалява програмиращите изрази, нужни на компютъра, за да работи, до 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 играе ключова роля в историята на програмирането. По това време компютрите са имали малка памет (около 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 се използват пет основни типа данни :

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

Пример – 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;

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

A = 10, B = 20;

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

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

A = true, B = false;

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

Името на променливатя може да съдържа букви, цифри и знака „_“. Имената във 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.

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

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

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

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

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

Пример:

Именуваните константи имат име и стойност. Именуваните константи трябва да се декларират в началото на програмата или процедурата, също като при декларация на тип променлива. Именуваните константи се декларират с атрибута 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 подпрограмите имат една-единствена цел – да приемат аргументи, да извършат манипулации, и да върнат само един резултат. Във 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 подпрограмите, за разлика от функциите, връщат няколко резултата; в основния метод се извикват с 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, името на функцията и аргументите, които тя приема.

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

През 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 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 код.

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

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