From Wikipedia, the free encyclopedia
FORTRAN е сред първите езици за програмиране от високо ниво. Името FORTRAN – (идва от FORmula TRANslator или „преводач на формули“, и до версия FORTRAN 77 се е изписвало с главни букви) – подсказва предназначението му за програмиране на изчислителни процеси. С времето езикът се усъвършенства и се превръща в универсален.
| FORTRAN | |
 Перфокарта за FORTRAN | |
| Парадигма | процедурен, императивен, структурен, обектно ориентиран |
|---|---|
| Реализиране през | 1957 |
| Автор | Джон Бакус |
| Типизация на данните | статична, силна |
| Повлиява | ALGOL 58, PL/I |
| Уебсайт | www.fortran.com |
| FORTRAN в Общомедия | |
С 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 са добавени шест нови инструкции :
През следващите няколко години към 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. Той включва:
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, като :
Пример: 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 са добавени:
Пример: 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) като:
Разширен е наборът от съществени функции (например аргументът „dim“ е добавен към „maxloc“).
Няколко функции, регистрирани като „отпадащи от употреба“ още във Fortran 90, са премахнати от Fortran 95:
Езикът Fortran 95 също включва два избираеми модула:
Те заедно формират International Standard (ISO/IEC 1539).
Fortran 2003 (2004)
Fortran 2003, официално издаден като ISO/IEC 1539 – 1:2004, е версия, въвеждаща много нови подобрения. Част от тях са:
Fortran 2008 (2010)
Последната излязла версия на езика е ISO/IEC 1539 – 1:2010, неформално известна като Fortran 2008. Тя е одобрена през септември 2010 година. Както при Fortran 95, това е минимално надграждане, обединяване, избистряне и корекция на предходната версия Fortran 2003. Част от новите възможности, които дава версията, са : Подмодули – допълнителни структуриращи улеснения за модулите; заместват ISO/IEC TR 19767:2005;
Важно приложение към Fortran 2008 е Техническата спецификация на ISO (TS) 29113 за Допълнителна оперативна съвместимост на Fortran с езика C, която през май 2012 е предаденя на ISO за одобрение. Спецификацията подпомага достъпа до array дескриптора от езика C и позволява игнорирането на тип или ранк от аргументи.
Във 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 трябва да се подчиняват на следните правила:
Променливите се декларират в началото на програмата или подпрограмата.
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 подпрограмите имат една-единствена цел – да приемат аргументи, да извършат манипулации, и да върнат само един резултат. Във 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-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 подпрограмите, трябва да спазваме някои правила
Добра практика е, за да можем да разграничим коя функция е за входните данни, коя е основна и коя е за изходните данни – да ги разделяме с нов ред.
През 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 код.
  |
Тази страница частично или изцяло представлява превод на страницата Fortran в Уикипедия на английски. Оригиналният текст, както и този превод, са защитени от Лиценза „Криейтив Комънс – Признание – Споделяне на споделеното“, а за съдържание, създадено преди юни 2009 година – от Лиценза за свободна документация на ГНУ. Прегледайте историята на редакциите на оригиналната страница, както и на преводната страница, за да видите списъка на съавторите.
ВАЖНО: Този шаблон се отнася единствено до авторските права върху съдържанието на статията. Добавянето му не отменя изискването да се посочват конкретни източници на твърденията, които да бъдат благонадеждни. |
Seamless Wikipedia browsing. On steroids.
Every time you click a link to Wikipedia, Wiktionary or Wikiquote in your browser's search results, it will show the modern Wikiwand interface.
Wikiwand extension is a five stars, simple, with minimum permission required to keep your browsing private, safe and transparent.
