Ֆորտրան

**Ֆորտրան** (), բարձր մակարդակի ծրագրավորման առաջին լեզուն, որն ստացել է գործնական կիրառություն, ունի հեռարձակող և հետագա զարգացում։ Ստեղծվել է 1954-1957 թվականների ընթացքում մի խումբ ծրագրավորողների կողմից՝ IBM Corporation-ում Ջոն Բեքուսի գլխավորությամբ։ Ֆորտրան  անվանումը կարճ է FORmula TRANSlator-ի համար (Formula Translator): Ֆորտրանը լայնորեն օգտագործվում է հիմնականում գիտական և ինժեներական հաշվարկների համար։ Ժամանակակից Fortran-ի առավելություններից մեկն այն է, որ դրա վրա գրված ենթածրագրերի, ծրագրերի և գրադարանների մեծ թիվն է։ Ֆորտրանում գրված են մեծ թվով տարբեր մաթեմատիկական գրադարաններ (հիմնականում լեզվի հին տարբերակներով) գծային հավասարումների մատրիցային հանրահաշվարկի և լուծման համակարգերի համար, դիֆերենցիալ հավասարումների լուծման գրադարաններ, ինտեգրալ հավասարումներ և դրանց համակարգեր, գործառույթների մոտավորություն, հատուկ ֆունկցիաներ, Ֆուրիեի արագ վերափոխումներ, մաթեմատիկական վիճակագրություն և մաթեմատիկական այլ առարկաներ։ Այս գրադարանները սովորաբար գալիս են կազմողի հետ։ Նման մի շարք փաթեթներ ստեղծվել են տասնամյակների ընթացքում և հանրաճանաչ են եղել գիտական համայնքում մինչ օրս, օրինակ, IMSL:

Այս գրադարանների մեծ մասը իրականում մարդկության սեփականությունն է։ Դրանք մատչելի են կոդով, լավ փաստաթղթերով, կարգաբերված և շատ արդյունավետ։

Ժամանակակից Ֆորտրանը (Fortran 95 և Fortran 2003) ձեռք է բերել նոր համակարգչային ճարտարապետությունների համար արդյունավետ ծրագրավորման համար անհրաժեշտ առանձնահատկություններ։ Այն թույլ է տալիս օգտագործել ժամանակակից ծրագրավորման տեխնոլոգիաներ, մասնավորապես, ընդհանրացված և մոդուլային ծրագրավորում, OOP, մինչդեռ շարունակականությունը պահպանելով ավելի վաղ վարկածներով։ Ժամանակակից ֆորտրանի զարգացման համար հիմնական հասկացություններից մեկը զուգահեռությանը և վեկտորային գործողություններին աջակցելու միջոց է։

## Լեզվի ստանդարտների էվոլյուցիան
Ֆորտրանը ճիշտ ստանդարտացված լեզու է, ուստի այն հեշտությամբ տեղափոխվում է տարբեր հարթակներ։ Լեզվի նոր ստանդարտները հիմնականում պահպանում են շարունակականությունը ավելի հիների հետ, ինչը թույլ է տալիս օգտագործել նախկինում գրված ծրագրերի կոդերը և փոփոխել դրանք։ Ընդ որում, լեզվի զարգացմանը զուգընթաց նախապես հայտարարվում են հնացած կառուցվածքներ, որոնք ապագայում, հնարավոր է, հեռացվեն։

### FORTRAN 66 (1972)
: IBM FORTRAN IV ստանդարտի հիման վրա

thumb|FORTRAN-77-ի ծրագիրը կոմպիլյատորի տրամադրմամբ

### FORTRAN 77 (1980)
: Ներդրվել են բազմաթիվ բարելավումներ.

# Ներկայացվում են ֆայլի (OPEN, CLOSE) բացման և փակման և ստանդարտ սարքի ելքի օպերատորները՝ PRINT:
# Ավելացվել է տվյալների տողերի տեսակը և դրա մշակման գործառույթները։
# Ներդրվեց `IF`     բլոկային օպերատորը և դիզայնը  `IF THEN` — `ELSE IF THEN` — `END IF`,  ինչպես նաև ծրագրի հատվածի ներառման օպերատորը `INCLUDE`.
# Ներկայացվել է  մուտքի ֆայլերի հետ աշխատելու հնարավորություն։
# Զանգվածի առավելագույն չափը ավելացել է 3-ից մինչև 7-ը։ Զանգվածի ինդեքսի սահմանափակումները հանվել են։
# Կատարելագործվել և ընդլայնվել են ընթացակարգերի հետ աշխատելու հնարավորությունները։
# Ներկայացվում է ներքին ֆայլի հայեցակարգը (որոնք զանգված են, թվային և լարային փոփոխականներ)։  Ներքին ֆայլերը թույլ են տալիս, մասնավորապես, թվային գծի և գծի համարների վերափոխումը ՝ օգտագործելով ստանդարտ ընթերցող և գրող օպերատորներ`READ` и `WRITE`։

### Fortran 90 (1991)
: Լեզվի ստանդարտը զգալիորեն վերանայվել է.

# Ներկայացվել է կոդ գրելու անվճար ձևաչափ։ Հայտնվեցին լրացուցիչ նկարագրություններ`IMPLICIT NONE`, `TYPE`, `ALLOCATABLE`, `POINTER`, `TARGET`, `NAMELIST`.
# Ներկայացրեցին վերահսկման օպերատորները և ձևավորումները:Ավելացված`DO` … `END DO`, `DO WHILE`, կառավարման փոխանցման օպերատոր ցիկլի սկզբում`CYCLE`,  ընտրության ձևավորում`SELECT CASE` ( `IF` -ի և GOTO օպերատորների  կառուցվածքները փոխարինելու համար), ինչպես նաև վերջնական օպերատորը ծրագրի միավորի, մոդուլային կամ ներքին `END` ընթացակարգի։
# Ներկայացվել է ցուցիչների գործիքակազմը և գործառույթներն օպերատիվ հիշողության հետ աշխատելու համար (C լեզվի նմանությամբ)։
# Գործարկվել են դինամիկ հիշողության օպերատորներ (`ALLOCATE`, `DEALLOCATE`, `NULLIFY`)։
# Ավելացված ծրագրային բաղադրիչներ`MODULE`, `PRIVATE`, `PUBLIC`, `CONTAINS`, `INTERFACE`, `USE`, `INTENT։`
# Ներդրվել է զանգվածների յուրացման քողարկում (յուրացում՝ առանց օպերատորների օգտագործման պայմանների զանգվածի տարրերի վրա դրված տրամաբանական պայմանի կատարման դեպքում), ինչպես նաև զանգվածների հատվածամասերի հետ աշխատանքը։ Ներդրվեց օպերատոր և WHERE դիզայն մասնակի փոխարինման ցիկլերի (ճիշտ մասը հանձնարարական օպերատորի չի փոխվել)։ Յուրացման քողարկումը տարածվում է գրեթե բոլոր օպերատորների, կառուցվածքների և գործառույթների վրա, որոնք գործում են զանգվածների հետ։
# Հանձնարարության, լրացման, հանման, ինչպես նաև մի շարք բաժանման և բազմապատկման ստանդարտ գործողությունները տարածվում են զանգվածների և դրանց բաժինների վրա, որոնք սահմանված են բաժիններով։ Այս դեպքում կատարվում է առարկայական հանձնարարություն։
# Հայտնվել են նոր ներկառուցված առանձնահատկություններ, առաջին հերթին, հետ աշխատելու զանգվածների. Գործառույթները հաշվարկելու զանգվածների։ ALL (log. արտադրանքը) և MASK (տրամաբանական լրացում), COUNT (համարը ճշմարիտ տարրերի), PRODUCT (զանգվածի տարրերի արտադրյալ), SUM ( զանգվածի տարրերի գումար), DOT_PRODUCT (սկալյար արտադրյալ), MATMUL (բազմապատկում մատրիցով)։ Ավելացվել են օգնության գործառույթները, ավելացվեցին օգնության գործառույթները, ինչպես նաև զանգվածների վերափոխման և հավաքման գործառույթները։
# Լեզվի մեջ OOP-ի տարրեր են հայտնվել։ Ներկայացված տվյալների ստացված տիպերը։  Առանձին-առանձին հայտարարվել է լեզվի հնացած առանձնահատկությունների ցանկը, որոնք նախատեսված են ապագայում ջնջելու համար։
# Տվյալների հետ աշխատելու համար լրացուցիչ գործառույթներ են ավելացվել, մասնավորապես՝  TRIM (հետագծման տարածքների հեռացում) գործառույթները և REPEAT (տողի բազմակի պատճենումը) և ձախ և աջ հավասարեցման գործառույթները։

### Fortran 95 (1997)
: Նախորդ ստանդարտի շտկում։ Ներկայացվել է`FORALL`  հայտարարությունն ու կառուցվածքը, ինչը թույլ է տալիս ավելի ճկուն լինել, քան օպերատորի և `WHERE  դիզայնի,`  նշանակել զանգվածներ և փոխարինել  փոխարինել դժվար ցիկլեր։ `FORALL` - ը թույլ է տալիս փոխարինել ցանկացած բաժնի առաջադրանքին կամ օպերատորին, և   `WHERE` դրույթը, մասնավորապես, հնարավորություն է տալիս մուտք ունենալ մատրից՝ անկյունագծով։ Տվյալ օպերատորը համարվում է հեռանկարային զուգահեռ հաշվարկներում՝ նպաստելով ավելի արդյունավետ, քան ցիկլերը, տարածվածության իրականացմանը։
: OOP-ի աջակցության հետագա զարգացումը լեզվում,  օպերացիոն համակարգի  փոխազդեցության հետ։ Ավելացված է նաև  հետևյալ հատկանիշները

### Fortran 2003 (2004)
: ՕՕՊ աջակցման հետագա զարգացում։ Ավելացվել են նաև հետևյալ հնարավորթւոյւնները.

# Մուտքային–ելքային տվյալների մուտքագրում
# **C  լեզվի հետ փոխազդեցության միջոցներ**
# Տվյալների դինամիկ տեղադրման կատարելագործում։

### Ֆորտրան 2008 (2010)
: Ստանդարտը ենթադրում է աջակցություն զուգահեռ հաշվողական լեզվով (Co-Arrays Fortran): Նախատեսվում է նաև զանգվածների առավելագույն չափը հասցնել 15-ի, ավելացնել ներկառուցված հատուկ մաթեմատիկական ֆունկցիաներ և այլն։

### Ֆորտրան 2018
Ֆորտրան 2018-ի վերջին տարբերակը (նախկինում հայտնի էր որպես ֆորտրան 2015) թողարկվել է 2018-ի նոյեմբերի 28-ին։

Fortran 2018 ներառում։

* ISO / IEC TS 29113: 2012 Հետագա համատեղելիությունը C- ի հետ
* ISO / IEC TS 18508: 2015 Ֆորտրանի  լրացուցիչ զուգահեռ գործառույթները
* Աջակցություն  ISO / IEC / IEEE 60559: 2011, տասնվեցական մուտքագրում /  եզրակացություն, .IMPLICIT NONE բարելավումներ և այլ փոփոխություններ։

## Լեզվի  առանձնահատկությունների բնութագիրը
Ֆորտրանն ունի ներկառուցված մաթեմատիկական ֆունկցիաների մեծ հավաքածու, աջակցում է երկակի և բարձր ճշգրտության ամբողջական, իրական և համալիր թվերի հետ (երկուական գործողությունների ժամանակ օգտագործվում է real(10)), ունի զանգվածների և արտաքին ֆայլերի հետ աշխատելու հարուստ գործիքակազմ։ Ժամանակակից Ֆորտրանը (2003 և ավելի բարձր) ունի լիարժեք գործիքակազմ, սիմվոլային տվյալների հետ աշխատելու համար։

Սկզբում լեզվի արտահայտիչ միջոցներն այնքան էլ մեծ չէին, քանի որ Ֆորտրանը իրացված առաջին բարձր մակարդակի լեզուն էր։ Հետագայում Ֆորտրան են ավելացվել բազմաթիվ բառային կառուցվածքներ, որոնք բնորոշ են կառուցվածքային, մոդուլային, ընդհանրացված և օբյեկտային կողմնորոշված ծրագրավորման համար

### Կոդի գրառման ձևաչափ
Կառուցվածքը ծրագրերի սկզբանե կենտրոնացած է մուտքագրման հետ պերֆոկարտ և ուներ մի շարք հարմար է այս դեպքում հատկություններով։ Այսպիսով, 1-ից մինչև 5-րդ սյունակում եղել է պիտակի տարածքը, 6-Ես ծառայել եմ տեքստի պիտակավորման համար որպես նախորդ գծի շարունակություն (ցանկացած խորհրդանիշ, բացի տարածությունից և «0»-ից), իսկ 7-ից մինչև 72-ը եղել է օպերատորի կամ մեկնաբանության տեքստը։ 73-ից 80-ի սյունակները կարող էին ծառայել քարտերի համարակալմանը (պատահաբար ցրված տախտակամածը վերականգնելու համար) կամ կարճ մեկնաբանության համար, նրանք անտեսվում էին հեռարձակողի կողմից։ Եթե Օպերատորի տեքստը չի տեղավորվում հատկացված տարածության մեջ (7-ից 72-րդ սյունակում), ապա հաջորդ քարտի 6-րդ սյունակում դրվում էր շարունակության նշանը, ապա օպերատորը շարունակում էր դրա վրա։ Տեղադրել երկու կամ ավելի օպերատոր մեկ տողում (քարտեզ) չի կարող լինել։ Երբ բռունցքները պատմության մեջ են մտել, այդ արժանիքները լուրջ անհարմարությունների են վերածվել։

Սա է պատճառը, որ ֆորտրանի ստանդարտը, սկսած ֆորտրան 90-ից, պահպանելով ֆիքսված տեքստի ձևաչափը, ավելացվել է ազատ ձևաչափ, որը չի կարգավորում գծի դիրքերը և  թույլ է տալիս արձանագրել մեկից ավելի օպերատորներ։ Ազատ ձևաչափի և կառուցվածքային ծրագրավորման ժամանակակից մեթոդների ներդրումը թույլ է տվել ստեղծել կոդ, որի ընթերցելիությունը և պարզությունը չի զիջում ծրագրավորման այլ ժամանակակից լեզուների օգնությամբ ստեղծված կոդին, ինչպիսիք են Պասկալը, C կամ Java-ն։ Ժամանակակից զարգացման միջավայրերը թույլ են տալիս համատեղել ձևաչափերը, օրինակ, ընդլայնել գծի երկարությունը մինչև ազատ ֆորմատ (սովորաբար 132 նիշ), թույլ է տալիս Ձեզ արձանագրել մի քանի օպերատորների անընդմեջ, բայց միևնույն ժամանակ, դուք կարող եք նաև պահպանել նահանջը դեպի ձախ (անել ձախ դաշտը), որը բնորոշ է հին ֆիքսված ձևաչափով, դրանով իսկ թողնելով նվիրված սյունը համար սխալի պիտակների և ձևաչափերով, ինչպես նաև շարքով շարունակման սյունը։

Հին ֆորտրանի  «այցեքարտը» հսկայական քանակությամբ պիտակներ է, որոնք օգտագործվել են GOTO-ի անվերապահ անցման օպերատորներում, ցիկլերի օպերատորներում, պայմանական օպերատորներում և ֆորտրանի պաշտոնական նկարագրության օպերատորներում։ GOTO-ի մեծ թվով պիտակները և օպերատորները հաճախ դժվարացնում էին Ֆորտրանի ծրագրերը հասկանալու համար։

Հենց այս բացասական փորձն է պատճառը, որ ծրագրավորման մի շարք ժամանակակից լեզուներով (օրինակ՝ Java լեզվով) պիտակները և դրանց հետ կապված անվերապահ անցման օպերատորները խիստ ձևափոխված են։

Սակայն ժամանակակից Ֆորտանը (հիմնականում Fortran'90-ի տարբերակից սկսած) ազատվել է պիտակների ավելցուկից այնպիսի օպերատորների ներդրման շնորհիվ, ինչպիսիք են  `DO` … `END DO`, `DO WHILE`, `SELECT CASE`, конструкции `IF THEN`-`ELSEIF THEN`-`ELSE`-`END IF` –ը և այլն։ Ավելին, լեզվի ժամանակակից ստանդարտներում մնացել է միայն դասական  `GOTO` օպերատորը, որը կիրառվում է բազմաթիվ լեզուներով և  այսօր։  `GOTO`-ի հաշվարկվող օպերատորը, ինչպես նաև`ENTRY`— ի բազմակի մուտքի դիզայնը, հանվել են ստանդարտից, թե, որպես կանոն, շարունակում են պահպանվել կոմպիլյատորների կողմից։

Հաստատուն ձևաչափ (1-ից 6 տողերի դիրքերում տողերի տառատեսակներ)
```fortran
␣␣␣␣␣␣PRINT*, 'Hello, World!'
␣␣␣␣␣␣END
```
Ազատ ֆորմատ։
```fortran
print *, "Hello, World!"
end
```


; Դիտողություններ.

* Հիմնական PROGRAM ծրագրի մեկնարկի օպերատորը պարտադիր չէ։ Խստորեն, Ֆորտրան ծրագրի միակ պահանջվող օպերատորը  `END`  օպերատորն է։
* Ծրագրային հայտարարություններ գրելու համար մեծատառ կամ փոքրատառ տառերի ընտրությունը կամայական է։ Ֆորտրանի ժամանակակից ստանդարտների առումով շատ մեծատառեր և շատ փոքրատառեր նույնն են։

### Տվյալների տեսակները
Ֆորտրանն աջակցում է 5 հիմնական տարրական ներկառուցված տվյալների տիպերին՝վավեր (*<code>REAL</code>*), համապարփակ (*<code>COMPLEX</code>*), ամբողջական (*<code>INTEGER</code>*)  со  նշանով կամ առանց, տրամաբանական (*<code>LOGICAL</code>*) և  սիմվոլիկ (*<code>CHARACTER</code>*): Բացի այդ, հնարավոր է ստեղծել ածանցյալ տվյալների տեսակներ, օգտագործելով `TYPE` հիմնաբառը։ Լեզվի ստեղծման հենց սկզբից գոյություն են ունեցել 4 տեսակի տվյալներ՝ վավեր, համալիր, ամբողջական և տրամաբանական։

Կա մի հասկացություն տեսակի տվյալների կամ տեսակի պարամետրերի։ Սա թույլ է տալիս պարամետրավորել իրական և համապարփակ տվյալներ (այսինքն, ցույց տալ, ճշգրտությունը և տեսականին տասնորդական կարգով) և այլ տվյալներ, բարձրացնելով շարժունակությունը դիմումների։

Բոլոր թվային տվյալների հայտնաբերվել սովորական թվաբանական գործառնությունների և յուրացման, կան ներկառուցված գործառույթները։ Ներկառուցված Log(x) ֆունկցիան, որպես X փաստարկ, կարող է ունենալ միայն վավեր կամ համալիր թիվ (ոչ ամբողջ)։

Որպես կանոն, 4 բայթը հատկացվում է «մեկ» ճշգրիտ ճշգրտության իրական համարի (REAL (4)) կամ KIND = 4 տիպի պարամետրին, «կրկնակի»՝ 8 բայթ։ Կոմպլեքս թվերի դեպքում բայթերի քանակը կրկնապատկվում է։

Ամբողջ թվերը կարող են զբաղեցնել 1-ից 4 բայթ։ Ժամանակակից կոմպիլյատորները թույլ են տալիս ծրագրավորողին գործել թվերով և «ստուգված»  ճշգրտությամբ։

Թվաբանական գործողություններում տիպի փոփոխությունը կատարվում է ամբողջությամբ վավեր և հետագայում համալիր թվերով, կամ հատուկ ներկառուցված թվային ֆունկցիայի կիրառմամբ։ Այնքան, համարժեք են հետևյալ արտահայտությունները(*i* —ամբողջ)։ `Log(''i*''1''.'')` և `Log(real(''i''))։`

Լարային (սիմվոլային) տվյալները տրվում են փակագծերում երկարության նշումով կամ տիպի հատկանիշից հետո կամ գծի անվանումից հետո։ Ծրագրի մարմնում տողերի առաջադրման համար օգտագործվում են մեկ կամ կրկնակի չակերտներ։ Այնքան, համարժեք է ռեկորդային։ A= 'It is hot' կամ A= «It is hot»։ Այն հարմար է այն դեպքերում, երբ տողում առկա են չակերտներ։ B= «It isn ' t hot»։

Տողերի համար կա ներկառուցված գործողություն՝ տողեր միավորելու (ավելացնելու) տողերի համար՝ //: Նիշերի տվյալների համար կա 17 մասնագիտացված ներկառուցված գործառույթ (ի լրումն ունիվերսալ գործառույթների, որոնք մշակում են բոլոր տեսակի տվյալները)։

Նշանները 5-ից ոչ ավելի թվերի թվով ամբողջ թվեր են՝ խորհրդանիշները չեն թույլատրվում։ Պիտակները օգտագործվում են GOTO-ի օպերատորների, ընթերցանության, գրելու և ֆորմատավորման օպերատորների, ինչպես նաև սխալների և բացառությունների մշակման ժամանակ։ Բացի նշագծից, Ֆորտրանում կա կառավարման կառույցներ (ցիկլեր, տրամաբանական պայմաններ, կառուցվածքներ `FORALL`… `END FORALL`, `WHERE`… `END WHERE`, `SELECT CASE`… `END SELECT`, `TYPE`… `END TYPE` և այլն), ընդ որում, անունը դիզայնի կարող է պարունակել ցանկացած թույլատրելի անուն փոփոխականների նիշ։

#### Ներկառուցված գործառույթներ նիշերի տվյալների համար
Փոխանցել համարը նիշի՝ `CHAR(i)` и `ACHAR(i)։Փոխարկեք ամբողջը իր համապատասխան օպերացիոն համակարգի բնույթի կամ ASCII բնույթի։`

Նիշից-թվին փոխարկման համար `ICHAR(i)` и `IACHAR(i)։` Իրականացրեք հակադարձ վերափոխումներ։

Տողի համեմատության ֆունկցիաները՝ `LGE(A,B)`, `LGT(A,B)`, `LLE(A,B)` и `LLT(A,B)։ Ֆունկցիաների արդյունքը «ճշմարիտ» է, եթե ASCII սիմվոլներով արտահայտված տողերի երկարությունները (L(A) և L(B) բավարարում են հետևյալ անհավասարություններին համապատասխանաբար․`  *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)։*

Ֆունկցիայի երկարությունը `LEN(A)` и `LEN_TRIM(A)։Առաջինը վերադարձնում է A  տողի երկարությունը (նիշերի քանակը), երկրորդը վերադարձնում է տողի երկարությունը՝ առանց հետքեր տեղակայելու, եթե այդպիսիք կան։`

Փոխակերպման ֆունկցիաներ `TRIM(A)`, `ADJUSTL(A)` и `ADJUSTR(A)`, `REPEAT(A,N)։ՖունկցիաTRIM(A)` –ն վերադարզնում է   *A  տողը առանց հետագծի։*   `ADJUSTL(A)` иև `ADJUSTR(A)`  ֆունկցիաները  հավասարեցնում են  գիծը (հեռացնել բացերը) ձախը և աջը համապատասխանաբար։  `REPEAT(A,N)`   ֆունկցիան  վերադարձնում է տողի A պատճենները։

Որոնման ֆունկցիաները  տողում   `SCAN(A,B,[''back''])`, `INDEX(A,B,[''back''])`, `VERIFY(A,B,[''back''])։`Ընտրովի back պարամետր սահմանում է որոնման ուղղությունը,  ձախ ուղղության համար (`''back=.false.''`)  իսկ աջ ուղղության համար  (`''back=.true.''`)։

`SCAN`   ֆունկցիան որոշում է B տողերի ցուցակից հայտնաբերված առաջին սիմվոլի A (ձախ կամ աջ) տողի դիրքի համարը։  Եթե արդյունքը բացասական է, գործառույթը կվերադարձնի  0  թիվը։   `INDEX` ֆունկցիան որոշում է դիրքի համարը, որով առաջին անգամ սկսվում է տողի ամբողջական մուտքը *А*  տող։ Ավելին, որոնումը կարող է իրականացվել ինչպես ձախից, այնպես էլ աջից, բայց դիրքի համարը միշտ հաշվարկվում է ձախից՝ գծի սկզբից։ Եթե որոնումը ձախողվի, ֆունկցիան կվերադարձնի  0։   `VERIFY ֆունկցիան`   `INDEX  ֆունկցիայի հակադարձն է`։ Այսպիսով,   `VERIFY`  –ը   վերադարձնում է A-ի նման տողի խորհրդանիշի դիրքի համարը, որը չունի դիմակավոր տողում։ Եթե բոլորը (տարբեր) տողի խորհրդանիշները A-ն առկա են դիմակավոր տողում, ապա գործառույթը կվերադարձնի 0։

Այս բոլոր գործառույթները տարրական են, և դրանց փաստարկը կարող է լինել նիշերի կամ ամբողջ թվերի շարք։ Արդյունքը կլինի հետևողական թվային, բնույթի կամ տրամաբանական զանգված։

Ֆորտրան ստանդարտները, սկսած 2003-ի տարբերակից, ապահովում են Յունիկոդա նիշերի հետ աշխատելու հնարավորություն։

Այս հատկություններից բացի, Ֆորտրանը թույլ է տալիս մշակել նիշերի տվյալները՝ օգտագործելով ներկառուցված մատրիցային (վեկտոր) վերլուծություն, ինչը էապես մեծացնում է նիշերի տվյալների մշակման ճկունությունը։

Ֆորտրանում, C- ի ծրագրերին համապատասխանության համար, կա C- տողի հասկացություն, որը նշվում է չակերտից հետո c ավելացնելով՝ A = Սա C- պարանի է։ Զրոյական գիծը սահմանվելու է այսպես՝ *А=՛0’c։*

### Ենթածրագրեր (ընթացակարգեր և գործառույթներ)
Ֆորտրանում ենթածրագրերը գոյություն ունեին հենց առաջին ստանդարտից և մինչ օրս շարունակում են մնալ հիմնական ծրագրավորման գործիքներից մեկը։

Ֆորտրանում ենթածրագրերը, գործառույթները և դրանց պարամետրերը կոչվում են բացառապես հղումով (և ոչ թե ըստ արժեքի)։ Հետևաբար, ենթածրագիրը կարող է փոխել հիմնական ծրագրում դրան փոխանցված փաստարկը, եթե դա հատուկ եղանակով չի կանխվում։ Այս մեխանիզմը թույլ է տալիս կատարել բնական նոտացիա մաթեմատիկական բանաձևեր գրելիս, և միևնույն ժամանակ պահպանել բարձր կատարողականություն՝ տվյալների մեծ զանգվածների հետ աշխատելիս։

Ֆորտրանի ենթածրագրերը կարող են պարունակել պարամետրերի ցանկում (կոչվում են ֆորմալ պարամետրեր) և ընտրովի (ընտրովի) պարամետրեր, և  կարող են ընդհանրապես պարունակել պարամետրեր։

Լեզուների ստանդարտը թույլ է տալիս գերբեռնված ընթացակարգերը և գործողությունները ընդհանուր ինտերֆեյսի միջոցով համատեղել տարբեր ընթացակարգեր (յուրաքանչյուր գործառույթ, օրինակ, ամբողջ թվերով, իրական, կոմպլեքս թվերով և խորհրդանշական փոփոխականներով) մեկ (ընդհանուր) անվան տակ։ Այս դեպքում, հիմնական ծրագրում, բավական է անդրադառնալ ընդհանուր ընթացակարգին, իսկ կատարված գործողությունների բնույթը կախված կլինի մշակման կարգով առաջարկվող տվյալների տեսակից։ Այս սկզբունքով կատարվում են ներկառուցված բոլոր գործառույթներն ու ենթաառաջատարները, օրինակ՝ COS (x): Ընթացակարգերի, գործառույթների և օպերատորների ծանրաբեռնվածությունը (ավելին, ծրագրավորողը կարող է առաջարկել ծանրաբեռնված օպերատորների խորհրդանիշներ, բացի ներկառուցվածներից), տարածվում է ոչ միայն ներկառուցված տվյալների տեսակների, այլև ծրագրավորողի կողմից սահմանված տեսակների վրա։

#### Ենթածրագրերի տեսակներ
Ընթացակարգերը բաժանվում են ենթածրագրերի և գործառույթների. Ենթածրագրերը ավելի հարմար է, եթե դուք պետք է վերադարձնել մեծ թվով տարբեր արդյունքների՝ գործառույթները-երբ վերադարձը արդյունքում մեկ տեսակի (այդ թվում, զանգված)։

Ենթածրագիրը սահմանվում է նկարագրության օպերատորի կողմից՝ `Subroutine` անուն_պոդծրագրեր (ձևական փաստարկների ցուցակ), ֆունկցիա-օպերատոր`Function` անուն_ֆունկցիա (ցանկը պաշտոնական փաստարկների)։

Ենթածրագիրը կոչվում է օպերատորի կողմից՝ `Call` անուն_պոդծրագրեր (փաստացի փաստարկների ցուցակ)։ Ֆունկցիայի կանչը կատարվում է անունով՝ նշելով փաստացի փաստարկների ցանկը և առանց որևէ հատուկ օպերատորի օգտագործման։

F'90 ստանդարտից սկսած, պահպանվում են ռեկուրսիվ ընթացակարգեր (որոնք բացակայում են սահմանափակ մեքենայական հիշողության պատճառով վաղ տարբերակներում), որոնց հայտարարման համար անհրաժեշտ է հստակ բնութագիր`recursive։ Այս դեպքում գործառույթի արդյունքը պետք է տարբերվի ինքնին գործառույթի անունից։`

Մաքուր ընթացակարգեր և գործառույթներ (մաքուր ենթաառաջին [գործառույթ]) - F 95 ստանդարտի կողմից ներդրված ընթացակարգեր և գործառույթներ, որոնք չունեն կողմնակի բարդություններ։ Մաքուր գործառույթը պետք է վերադարձնի արժեքը և չպետք է փոխի իր մուտքի որևէ պարամետրը և / կամ գլոբալ տվյալները. մաքուր ընթացակարգը պետք է փոխի միայն այն պարամետրերը, որոնք հստակորեն նշված են որպես արդյունքի (ելք)՝ նպատակային հատկանիշի միջոցով (դուրս կամ ներգնա)։ Ֆորտրանում կողմնակի բարդությունների հնարավորությունը (այսինքն, ի վերջո, ենթածրագրում հիմնական ծրագրում փոփոխականները փոփոխելու ունակությունը) հանդիսանում է հասցեին անցնելու արագ եղանակի կողմնակի ազդեցություն։

Մաքուր ծրագրի միավորները չեն կարող պարունակել I / O օպերատորներ (WRITE և READ) արտաքին ֆայլերում և սարքերում, ներառյալ ստեղնաշարը և էկրանը, ինչպես նաև դադար և դադարեցնելու ծրագրեր։ Ֆորտրանի ներկառուցված բոլոր գործառույթներն ու ռեժիմները, ներառյալ մաթեմատիկական (բացառությամբ գործառնական համակարգի, ամսաթվի և ժամանակի գործառույթների և պատահական թվերի տվիչների), դրանք մաքուր են, այսինքն՝ դրանք չեն ստեղծում կողմնակի էֆեկտներ։ Ծրագրավորման մշակույթը բարձրացնելու և ալգորիթմների զուգահեռ արդյունավետության բարձրացման նպատակով ներդրվել են մաքուր գործառույթներ։

#### Ենթածրագրային արգումենտներ
Որպես ենթածրագրերի փաստարկներ կարող են լինել ցանկացած ներկառուցված տվյալների տեսակներ, ներառյալ զանգվածները և դրանց հատվածները, ցուցիչները, ինչպես նաև ծրագրավորողի կողմից սահմանված տեսակները։ Ենթածրագրերի փաստարկները կարող են լինել նաև գործառույթներ և այլ ենթածրագրեր, բացի ներքին ենթածրագրերից, գործառնական գործառույթից, ընդհանուր (ընդհանրացված) ընթացակարգերից (միայն կոնկրետ անուններ թույլատրվում են) և որոշ այլ ներկառուցված տեսակների։

Փաստարկները բաժանվում են ֆորմալ և փաստացի։ Փաստարկները փակագծերում են ենթածրագրի անվանումից հետո և  բաժանվում են ստորակետերով։ Փաստացի և ձևական փաստարկների անունները կարող են համընկնել։

Ֆորմալ փաստարկները նրա նկարագրում նշված ենթածրագրի (գործառույթի) փաստարկներն են։ Եթե սուզանավը փաստարկներ չունի, փակագծերը կարող են բացակայվել։ Ֆունկցիայի փակագծերը տեղադրվում են պաշտոնական փաստարկների բացակայության դեպքում։ Ֆորմալ պարամետրերի կարգը կոչվում է պաշտոնական ընթացակարգ։

Փաստացի փաստարկները այն փաստարկներն են, որոնք փոխանցվում են ենթածրագրին կամ գործառույթին, այն կատարելու համար։ Ֆունկցիան առանց փաստարկների կոչվում է դատարկ ցուցակով փակագծերում, ենթածրագրով՝ առանց փակագծերի։

Ֆորմալ և փաստական փաստարկները պետք է լինեն հետևողական։ Նրանց տեսակի փաստարկներն ու տեսակները պետք է լինեն նույնը, նույն կազմաձևի զանգվածը (կամ զանգվածի բաժինը) պետք է համապատասխանի զանգվածին։

Կան արայս, անփոխարինելի կոնֆիգուրացիան և ընդունող կազմ, որպես ձևական փաստարկների ընթացակարգեր։ Կոնֆիգուրացիան փոխող զանգվածը ձևական փաստարկ է ՝ զանգված, որը ժառանգում է իրեն համապատասխան փաստացի զանգվածի կոնֆիգուրացիան։ Նման զանգվածի համար, երբ այն հայտարարվում է, նշվում է մի հարթություն (համընկնելով փաստացի զանգվածի փաստարկի հարթությանը), իսկ վերին սահմանները բացակայում են։ Լռելյայն, ստորին սահմանները 1 են, բայց դրանք կարող են սահմանվել կամայականորեն։ Կազմաձևը ստանձնող զանգվածի տարրերի քանակը և արժեքը ճշգրիտ ժառանգված են իրական զանգվածի փաստարկից։ Չափը ստանձնող զանգվածը ավելի վաղ Ֆորտրանի 77 լեզուն է, որը մնացել է համատեղելիության՝ նկարագրելու ժառանգական զանգվածները։ Նման զանգվածների համար ժառանգվում է միայն վերջին հարթությունը, որի վերին սահմանը նկարագրվում է աստղանիշով (*): Այս դեպքում ֆորմալ և փաստացի փաստարկների զանգվածները կարող են ունենալ տարբեր հարթություններ։ Կազմաձևերը և չափերը ստանձնող զանգվածները չեն կարող դինամիկ լինել կամ ցուցիչ լինել։ Ընթացակարգերը, որոնք ունեն ժառանգական զանգվածներ, պետք է ունենան հստակ ինտերֆեյս։

Տողեր-ֆորմալ փաստարկները կարող են նաև ժառանգել (վերցնել) երկարությունը համապատասխան փաստացի փաստարկի տողում։ Երկարություն ունեցող տողերը նկարագրվում են սիմվոլի միջոցով*: Character (Len = *) անուն_ տողերը։ Տողի երկարության հստակ առաջադրանքի դեպքում տողի երկարությունը պաշտոնական փաստարկ է, որը չի կարող ավելի մեծ լինել համապատասխան փաստացի փաստարկ-տողից։

Արգումենտները դիրքային են և առանցքային։ Դրական պաշտոնական և փաստարկային փաստարկները կապված են միմյանց հետ`վիճաբանությունների ցանկում դրանց դասավորության կարգով, որը պետք է համապատասխանի։ Բանալիներ - ստեղնաշարի անունով, որը համապատասխանում է պաշտոնական փաստարկի անվանմանը։ Ստեղները թույլ են տալիս խափանել փաստարկների կարգը կամ բաց թողնել դրանցից մի քանիսը։ Այսպիսով ենթածրագրի հետ վերնագրի  համար `Subroutine` ONE (A, B, C, D) զանգը կարող էր այսպիսին լինել։`Call` ONE (D=*Z*, C=*Y*, B=*X*, A=*W*), где *W, X, Y, Z* — փաստացի փաստարկները։

Հիմնական փաստարկները թույլ են տալիս ունենալ ոչ պարտադիր փաստարկներ, որոնք կարող են բաց թողնվել։ Այս դեպքում ընտրովի փաստարկները պետք է ունենան Օպտիոնալ հատկանիշը։ Օրինակ, եթե տրվում է`Optional` *C, D*,  այդ դեպքում հնարավոր է`Call` ONE (B=*X*, A=*W*).

Ընտրովի պարամետրերով ընթացակարգերը պետք է ունենան հստակ ինտերֆեյս։

### Աշխատեք զանգվածների հետ
Զանգվածները ֆրակտոն փիլիսոփայության կենտրոնական կետն են։ Բոլոր լեզվի նմուշները, տվյալները, ծրագրային միավորները, օպերատորները, ներկառուցված գործառույթները, ցիկլերը ստեղծվում են և ստեղծվում են առաջին հերթին զանգվածների արդյունավետ մշակման համար։ Ֆորտրանը, քանի որ իր զարգացումը հետևում է առավելագույն, որքան հնարավոր է, հեռավորության վրա մանրամասն (բանաստեղծական) նկարագրությունից և զանգվածների մշակումից։ Դա հատկապես արդյունավետ է բազմաչափ զանգվածների մշակման ժամանակ (f2008 — 15 ստանդարտի զանգվածների սահմանային չափսերը)։ Այս տեսակետը զանգվածներին բնորոշ չէր լեզվի վաղ տարբերակներին; զանգվածների նկատմամբ ընդհանրացված մոտեցման առաջին տարրերը հայտնվել են FORTRAN77-ում՝ դրանք զարգանում են մինչ օրս։

Զանգվածները ստատիկ և դինամիկ են։ Դինամիկը բաժանվում է հատկացված և ավտոմատ ձևավորվում է։ Ֆորտրանում երկչափ զանգվածի տարրերը տեղադրվում են սյունակներում, ոչ թե շարքերում, ինչպես, օրինակ, C- ում։ Այսպիսով, զանգվածի առաջին ցուցանիշը փոխվում է առավել արագ։ Հետևաբար, արդյունավետ աշխատանքի հետ զանգվածների ներդրված ցիկլերի պետք է ինդեքսավորել ներքին ցիկլեր ձախ ինդեքսների, իսկ արտաքին — աջ։  Լռելյայն, զանգվածների հանձնումը, մուտքագրումը, ելքը և նախնականացումը կատարվում են սյունակներում։
```fortran
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
```
Զանգվածները կարող է լինել զրոյական չափի (այդ թվում, եթե ստորին սահմանը գերազանցում է վերին)։ Զանգվածների սահմանների ինդեքսները կարող են լինել ցանկացած ամբողջ թիվ։ Ըստ նախնականի, ստորին սահմանը հավասար է 1։
```fortran
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 համարի տողում այն կգրվի    ␣ ␣ ␣այ  ␣ ␣ ␣ ␣ հանձնարարություն ␣ ␣ ␣ ␣ տողի
```


#### Խաչաձև բաժինըզանգված, օպերատորներ<code>FORALL</code> и <code>WHERE</code>
Ֆորտրանը թույլ է տալիս արդյունավետ կերպով յուրացնել զանգվածները առանց ցիկլերի՝ օգտագործելով `WHERE`և FORALL օպերատորների, ինչպես նաև զանգվածների և վեկտորային ինդեքսների բաժինների միջոցով։ Բոլոր դեպքերում։ Ի սկզբանե հաշվարկվում է արտահայտության աջ մասը ամբողջությամբ (զանգվածների բոլոր ցուցանիշների համար) և միայն դրանից հետո կատարվում է հանձնարարություն՝ զանգված-դիմակ բավարարող ցուցանիշների համար։ Այս գործիքների օգնությամբ հաշվարկները թույլ են տալիս բարձրացնել արագագործությունը և հեշտացնել կոմպիլյատորին ծրագրի հատվածների ընտրության աշխատանքը, որոնք կարող են իրականացվել ինքնուրույն, այսինքն զուգահեռ։
```fortran
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 ! տարրերի գործառույթը հիմնականում կիրառվում է զանգվածի յուրաքանչյուր տարրի վրա

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
```
Հնարավոր են ավելի քիչ ակնհայտ գործողություններ
```fortran
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  3-րդ սյունակում 20-ի փոխարինումը 4-ով
! 21          22         23          24          25
```
Օպերատորի հնարավորությունները և FALL 95 ստանդարտի կողմից ներդրված FORALL կոնստրուկցիան ավելի լայն են, քան օպերատորի և WHERE կոնստրուկցիայի հնարավորությունները, բայց վերջինս, տրամաբանական մասնաճյուղի որոշ դեպքերում, պարզեցնում է ծածկագիրը այլընտրանքային ELSEWHERE- ի շնորհիվ՝ խուսափելով բնորոշ պայմանական հայտարարություններից և բարդ դիմակների շարքերից։

FORALL հայտարարությունն ու կառուցումը թույլ են տալիս միայն մաքուր ընթացակարգեր և գործառույթներ։ WHERE, FORALL-ի օպերատորների, ինչպես նաև զանգվածի համար հատուկ ներկառուցված գործառույթների (օրինակ, SUM) վրա հիմնված տրամաբանական զանգված-դիմակը հաշվարկվում է մինև յուրացումը և թույլ է տալիս փոխարինել ցիկլերը տրամաբանական պայմաններով նրանց ներսում, ինչը թույլ է տալիս խուսափել միկրոպրոցեսորի անցումների կանխատեսողի համար լրացուցիչ աշխատանք կատարելուց։

Վեկտորի ինդեքսը ամբողջ թվով միակողմանի զանգված է, որի արժեքները որոշ այլ զանգվածի ցուցանիշներ են։ Վեկտորի ցուցիչները օգտագործվում են բազմաչափ զանգվածների կամայական հատվածներ ստեղծելու համար և դրանց ընդհանրացումներ են։ Վեկտորի ինդեքսներ օգտագործելիս պետք է հետևել առաջադրանքի օպերատորի ձախ կողմում գտնվող ցուցիչների կրկնվող արժեքներին, քանի որ այս դեպքում փորձ է արվելու գրել մեկ հիշողությունների խցում, հնարավոր է, տարբեր արժեքներ։ Ինդեքսների կարգը կամայական է (չնայած որ դա չպետք է չարաշահվի, որպեսզի խուսափի կատարողականի անկումից)։
```fortran
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) ! վեկտորի ինդեքսների չափը պետք է համապատասխանի ձախ և աջ, և դրանց արժեքները չպետք է գերազանցեն դրանց օգտագործմամբ զանգվածների սահմանները
               ! վեկտորի ինդեքսները կարող են փոքր լինել, քան աշխատանքային զանգվածների չափը
```


#### Ներկառուցված գործառույթներ զանգվածի համար
Ժամանակակից Ֆորտրանայում կան մեծ թվով մասնագիտացված ներկառուցված գործառույթներ թվային և սիմվոլային զանգվածների հետ աշխատելու համար (Բացի վերը նշված ընդհանուր մեթոդներից)։ Ֆունկցիաների արգումենտներ են համարվում array թվային և / կամ սիմվոլային զանգված,*mask* տրամաբանական զանգված (որը, օրինակ, array>0 պայմանն է) և array զանգվածի dim չափումը, որը ձևավորում է (եթե տրված է dim փաստարկը) DIM համարով չափումներից մեկի երկայնքով զանգվածների հատվածքը։ Array array կարող է լինել, եթե այլ բան նշված չէ, թիվ, պարունակում է վավեր կամ համալիր համարները։ Եթե զանգված-դիմակ չի տրվում, ապա դրա արժեքը համարվում է նույնական ճշմարիտ։ Տրամաբանական զանգվածի դիմակը, եթե տրվում է, պետք է ունենա նույն ձևը, ինչպես array զանգված, կամ մասշտաբային ժեքը TRUE։

Հիմնական զանգվածը գործառույթների ներկայացրել է ստանդարտ F ' 90։

`ALL(mask[, dim])` — տրամաբանական գործառույթ՝ վերադառնում է «ճշմարիտ», եթե դիմակի տրամաբանական զանգվածի բոլոր տարրերը ճշմարիտ են (կամընտիր չափի երկայնքով մուգ) և հակառակը հակառակ դեպքում։

`ANY(mask[, dim])` —Տրամաբանական ֆունկցիա՝ ունի «ճշմարիտ» արժեք, եթե դիմակի տրամաբանական զանգվածի առնվազն մեկ տարրը ճշմարիտ է (dim-ի ընտրովի չափման երկայնքով)։

`COUNT(mask[, dim])` — ամբողջական գործառույթ՝ արդյունքը հավասար է դիմակների զանգվածի իրական տարրերի քանակին (ըստ ցանկության երկայնքով մուգ)։

`MAXLOC(array[, mask][, dim])`, `MINLOC(array[, mask][, dim])`,

—ամբողջական գործառույթները, որոնք համապատասխանաբար վերադարձնում են առավելագույն և նվազագույն տարրերի ինդեքսը (կամ առավելագույն և նվազագույն տարրերի ցուցանիշները) կամընտիր չափի երկայնքով`դիմակի զանգվածը բավարարող տարրերի համար։ Գործառույթները վերադարձնում են զանգվածի առաջին տարրի ցուցանիշը։ Եթե մութ գործառույթների վերաբերյալ փաստարկը նշված չէ, կամ եթե զանգվածը միակողմանի զանգված է, ապա արդյունքը գրվում է միակողմանի զանգվածում։

Բազմաչափ զանգվածների համար array-ի արդյունքը գրված է array-ի զանգվածով, մեկ միավորի համար, array-ի պակաս զանգվածով (բացառվում է dim-ի համարը)։

Ինդեքսների արժեքները հաշվարկվում են ըստ զանգվածի ստորին սահմանների կարգի։ Այսինքն, այն դեպքում, եթե array զանգվածի ստորին սահմանի համարը Տարբերվում է միավորից, ապա առավելագույն կամ նվազագույն զանգվածի տարրին մուտք գործելու համար պետք է ավելացնել maxloc և MINLOC գործառույթների արդյունքը ստորին սահմանի ինդեքսի և միավորի տարբերությունը։

`MAXVAL(array[, mask][, dim])`, `MINVAL(array[, mask][, dim])` — որոնման գործառույթները համապատասխանաբար առավելագույն և նվազագույն տարրերի համար, զանգվածային զանգվածում, տարրերի համար, որոնք բավարարում են դիմակների դիմակի զանգվածը `ըստ ցանկության մութ չափի։ Գործառույթի արդյունքը նույն տիպի և բազմազանության է, ինչպես զանգվածի զանգվածը։ Զանգվածի զանգվածը կարող է լինել միայն իրական կամ ամբողջական։

Միանգամայն զանգվածի, զանգվածի կամ մռայլ փաստարկի բացակայության դեպքում արդյունքը մասշտաբ է, հակառակ դեպքում`զանգվածը, որի աստիճանի մեկից պակաս դաս է, զանգվածի աստիճանից պակաս։

`FINDLOC(array, value[, dim][, mask])` — ֆունկցիան վերադարձնում է  *array զանգվածի* ամբողջ թիվ ցուցանիշը հավասար *value*։   Ներկայացված է F2008 ստանդարտով։ Փնտրվող զանգվածի տարրերը բավարարում են դիմակների տրամաբանական զանգվածը *mask* ըստ ցանկության չափման *dim*.Արգումենտի տեսակ  *value* –ը պետք է համապատասխանի *array տիպի*  զանգվածի տեսակին։ Ֆունկցիայի  մնացած հատկությունները նման են  `MAXLOC`   և  `MINLOC  ֆունկցիայի`  հատկություններին։  Начиная со стандарта F2003, функции `MAXLOC` и `MINLOC`, как и функция `FINDLOC`, գործում են նաև սիմվոլիկ տվյալներով։

`SUM(array[, mask][, dim])` и `PRODUCT(array[, mask][, dim])`   այս ֆուբկցիաները համապատասխանաբար իրականացնում են զանգվածային տարրերի գումարում  և բազմապատկում։ SUM և PRODUCT գործառույթների վերաբերյալ փաստարկների իմաստը նույնն է, ինչ վերը նշված գործառույթները։

PRODUCT ֆունկցիան գործում է f2003 ստանդարտից սկսած համալիր տվյալներով։

`DOT_PRODUCT(vector_1, vector_2)` իրականացնում է սկալյար արտադրությունն ըստ վեքթոր_1 և վեքթոր_2 վեկտորների գծային հանրահաշվի կանոնների (միաչափ զանգվածների) նույն չափի։ վեքթոր_1 և վեքթորr_2 միայնակ զանգվածները կարող են պարունակել ցանկացած թվային և տրամաբանական տիպի տվյալներ։ Վեկտորը վեքթոր_1 և վեքթոր_2 կարող է լինել կամ երկուսն էլ թվային, կամ երկուսն էլ տրամաբանական։

`MATMUL(matrix_a, matrix_b)` — կառուցված մատրիցային բազմապատկման գործառույթ։ Բազմապատկելով երկու մատրիցով, մատրիցով վեկտորի, վեկտորի վրա մատրիցով կանոնների գծային հանրահաշվի։ Մատրիքս_a և Մատրիքս_b ֆունկցիայի փաստարկները երկչափ կամ միաչափ թվային (ցանկացած ներկառուցված թվային տեսակների) կամ տրամաբանական զանգվածներ են։ Ֆունկցիայի փաստարկները չեն կարող միաժամանակ երկու վեկտորներ լինել՝ փաստարկներից մեկը պետք է լինի մատրիցա (երկչափ զանգված)։  Մատրիքս_b զանգվածի առաջին (կամ միակ) չափման տարրերի թիվը պետք է հավասար լինի Մատրիքս_a զանգվածի վերջին չափման տարրերի թվին։ ներկայացված է F'90 ստանդարտով։

Որոշ դեպքերում, երբ հաշվարկման վեկտորը սյունակ է վեկտորի-տողը, որը պահանջում է, երբ, օգտագործելով գործառույթը MATMUL լրացուցիչ վերափոխման վեկտորների մեջ ձևի մատրիցով `(/m,1/)` и `(/1,n/)`, MATMULl-ի արդյունավետությունը, ըստ Բարտենևի, զգալիորեն զիջում է սովորական ներդրված ցիկլին։

Ըստ NASA-ի թեստերի համար Matrix (երկչափ arrays), Intel-ի MATMUL կոմպիլյատորի արագագործությունը, օգտագործելով ամբողջական օպտիմալացում - O3-ը, զգալիորեն (որոշ դեպքերում ' կարգը) գերազանցում է ներդրված ցիկլերի արագագործությունը, թեև Matrix-ի համար ~1000×1000 և ավելի փոքր չափով զիջում է LAPAK-ի գրադարանի dgemm ենթածրագրի արագագործողությանը։ Միևնույն ժամանակ, Matrix ~100×100 և պակաս MATMUL գերազանցում է dgemm արագությամբ. IBM ֆիրմայի Ֆորտրանի կոմպիլյատորը, սկսած F ' 90-ի տարբերակից, MATMUL — ի համար օգտագործում է Խաղող-Շտրասենի բարդությունը {\rm O}(n^{2.81})։ Նկատի ունեցեք, որ մաթեմատիկական գործառույթների ստանդարտ ալգորիթմական ներդրումները սովորաբար չեն նշվում և մնում են կազմողի մշակողի հայեցողությամբ։

`MERGE(t_source, f_source, mask)` — ֆունկցիան, որը ստեղծում է նոր զանգված, որը վարում է դիմակ-զանգված, t_source-ի և f_source-ի նույն ձևի և նույն չափի տարրերից, ինչպես նաև բուն զանգվածները։ Arrays-փաստարկները և array-արդյունքը կարող է լինել ցանկացած ներկառուցված տեսակի և համընկնում ըստ տեսակի տվյալների, չափի և ձևի։

Եթե դիմակի տարրը ճիշտ է (.ТРUE.), ապա արդյունքի զանգվածի համապատասխան տարրը հավասար է t_source զանգվածի համապատասխան տարրին, եթե կեղծ է (FALSE.) - ապա f_source զանգվածի տարրին։

Ֆունկցիայի փաստարկները կարող են լինել ժայռերը, այս դեպքում, օրինակ, MERGE(a,0,c>=0)=A·Θ(c), որտեղ Θ (c) — ամբողջ թիվ Հեվիսայդի գործառույթը։

`MOVE_ALLOC(from, to)` — ներկառուցված ենթածրագիր, որը թույլ է տալիս ձեզ դինամիկ կերպով վերափոխել նախկինում տեղադրված դինամիկ զանգվածը նոր սահմաններով և չափերով, ինչպես դինամիկ զանգվածից։ Այս դեպքում, զանգվածից ստացված տվյալների պատճենվում է զանգվածին։ Անցյալից և զանգվածներից տվյալների տեսակը և աստիճանը պետք է համապատասխանի։ Զանգվածը տեղափոխելուց հետո զանգվածը ազատում է հիշողությունը և դառնում է չբաշխված։ Դա կարող է օգտակար լինել թվային մեթոդներով ՝ խնդրի տարբեր դիսկրեթինգով (բազմամյա և հարմարվողական մեթոդներ)։

Ներկայացված է ստանդարտ F2003- ով։

`TRANSPOSE(matrix)` — ֆունկցի, որը փոխադրում է (փոխարկում տողերը և սյուները) երկչափ մատրիցա։

Ժամանակակից  ֆորտրանը ներդնում է ներկառուցված գործառույթներ`  բազմաչափ զանգվածը փաթեթավորելու և բացելու համար միակողմանի զանգվածը (և, համապատասխանաբար, միակողմանի զանգվածից), տրամաբանական պայմանի վերահսկման տակ, տրամաբանական պայման ստեղծելու համար` արագությունը մեծացնելու և հիշողությունը պահպանելու համար։

`PACK(array, mask [, vector])` — ֆունկցիա; ցանկացած տիպի զանգվածի բազմաչափ զանգվածը փաթեթավորում է դիմակի տրամաբանական զանգվածի հսկողության տակ գտնվող միակողմանի վեկտորի զանգված։ Ընտրովի միակողմանի վեկտորի զանգվածը պետք է ունենա նույն տվյալների տեսակը, ինչպես զանգվածը, իսկ վեկտորի մեջ տարրերի քանակը, եթե նշված է, պետք է լինի առնվազն դիմակի իրական տարրերի քանակը։ Եթե դիմակը սկալար է արժեքով :TRUE., Ապա վեկտորի զանգվածում տարրերի քանակը, եթե նշված է, պետք է լինի ոչ պակաս, քան զանգվածում առկա տարրերի ընդհանուր քանակը։

Ֆունկցիայի  արդյունքը կլինի միատեսակ զանգված նույն տիպի, ինչպես զանգվածը։ Արդյունքի երկարությունը հավասար կլինի վեկտորի վեկտորի երկարությանը, եթե նշված է. եթե ոչ, ապա դիմակի զանգվածի դիմակում առկա իրական տարրերի քանակը։ Եթե վեկտորը նշված չէ, իսկ դիմակը ճշգրիտ արժեք ունեցող մասշտաբ է, ապա արդյունքում ստացվող միակողմանի վեկտորի երկարությունը հավասար է զանգվածի զանգվածի տարրերի քանակին։

Արդյունքում զանգված հետևողականորեն լրացվում է array զանգվածի տարրերով (համակարգչային հիշողության մեջ դրանց տեղադրման կարգով), որոնք բավարարում են mask զանգվածի իրական արժեքները։ Ընդ որում, եթե տրված է vector-ը, Դրանից ընտրվում են զանգվածում բացակայող (հնարավոր է) տարրեր ՝ արդյունքում, Ընդ որում, սկսած այն ցուցանիշից, որը վերջինիս հաջորդում է array զանգվածի իսկական տարրով։

Արդյունքում զանգվածը հաջորդաբար բնակեցված է զանգվածի զանգվածի տարրերով (այն կարգով, որ դրանք տեղադրվում են համակարգչային հիշողության մեջ), որոնք բավարարում են դիմակների զանգվածի իրական արժեքները։ Ավելին, եթե վեկտորը նշվում է, դրա արդյունքում ընտրվում են ստացվող զանգվածում բացակայող (հնարավոր) տարրերը, և սկսվում է զանգվածի զանգվածի իրական տարրը հաջորդից հետո վերջին ցուցակից։

Այսպիսով զանգվածի համար  A=\begin{bmatrix} 0 & 1 & 0 \\ 2 & 0 & 0 \\ 0 & 0 & 3 \end{bmatrix}

`PACK(A, mask=A.NE.0) ֆունկցիայի արդյունքը կլինի միակողմանի զանգված`  \begin{bmatrix} 1 & 2 & 3 \end{bmatrix}։ Եթե վեկտորը  նշված է V=\begin{bmatrix} 77 & -95 & 0 & 4 & 5 & 6 & 7 & 8 & 9 & 10 \end{bmatrix}, ապա արդյունքը `PACK(A, mask=A.NE.0, V)` будет

\begin{bmatrix} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 \end{bmatrix}։

### Մուտքի ելքի ֆայլեր
Ֆորտրանն ունի հարուստ ներկառուցված գործիքակազմ մուտքի–ելքի գործառնությունների համար, այդ թվում ՝   մեծ տվյալների զանգվածների համար։ Ֆայլերը Ֆորտրան են ներքին և արտաքին։

Ներքին ֆայլը ցանկացած զանգված է, սիմվոլիկ տող կամ ենթատող։ Ներքին ֆայլերը միշտ բաց են լռելյայն։ Արտաքին ֆայլը ցանկացած ֆայլ է, որը արտաքին է կատարված ծրագրի նկատմամբ

Երկու տեսակի ֆայլեր, որոնք օգտագործվում են նույն գրել և կարդալ կարդալ կարդալ կարդալ գրել օպերատորների։ Ներքին ֆայլերը, որոնք օգտագործվում են փոխարկել համարը-լարային-համարը և ստեղծել խառը թվային և խորհրդանիշ գրառումները։
```fortran
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
!...
```
Արտաքին ֆայլերը բաժանվում են ձևական (տեքստային, CR - և LF-հոսքերի), երկուական (երկուական), ուղղակիորեն ցուցադրելով RAM, և ոչ ֆորմալ (ոչ երկուական)։ Բացի այդ, դրանք կարող են լինել ֆիքսված և փոփոխական երկարության գրառումների ուղղակի և հաջորդական հասանելիության ֆայլեր (փոփոխական միայն հաջորդական ֆայլերի համար), ինչպես նաև հատվածավորված գրառումներ (շատ մեծ ոչ պաշտոնական հաջորդական ֆայլերի համար)։ Այսպիսով, Ֆորտրանը թույլ է տալիս ստեղծել և մշակել բավականին մեծ քանակությամբ ֆայլեր՝ 15 եղանակներ կազմակերպելու համար։ Մեկ գրառման առավելագույն չափը 2,14·10^{9} բայթ։

Ուղղակի մուտքի ֆայլերը թույլ են տալիս կատարել մուտքային-ելքային գործողություններ՝ նշված համարով գրառումներով (առանց ֆայլում վերը նշված կամ ներքոհիշյալ գրառումների կորստյան)։

Երբ դուք բացել սերիական ֆայլը, այն կարող է տեղադրվել սկզբին, վերջում (նախքան «վերջը ֆայլի»), որը թույլ է տալիս Ձեզ ավելացնել տվյալներ, քանի որ դրանք կուտակվում են առանց dutying նախկինում մտել, ինչպես նաև կամ սկզբին, կամ վերջում, կախված նախկինում սահմանված ֆայլի կարգավիճակի (Այն բացվել է նախկինում, թե ոչ)։

### Հիշողության հետ աշխատելը
Ժամանակակից ստանդարտներում լեզվի (սկսած Fortran'90 կամ Fortran'95) հնարավոր է աշխատել երեք տեսակի դինամիկ զանգվածների (ավտոմատ, տեղադրվող և զանգվածների-հղումներ), ցուցիչների, հղումների հետ, առկա են ներկառուցված ընթացակարգեր հիշողության հետ աշխատելու համար ուղղակիորեն և ընթացակարգեր կոտրված գործողությունների համար։

Լեզվի ստանդարտները ենթադրում են, որ ցանկացած տեսակի դինամիկ զանգվածով աշխատող RAM-ի ավտոմատ ազատումը, ծրագրի կամ ենթածրագրի (ընթացակարգեր, գործառույթներ) ավարտից հետո, նույնիսկ եթե ծրագրավորող ազատումը հստակ չի կատարվել։ Սա թույլ է տալիս խուսափել հիշողության արտահոսքից, երբ դինամիկ զանգվածների հետ աշխատելը Ֆորտրան միջոցներով (ցուցիչների օգտագործման և այլ դեպքերում հնարավոր է արտահոսք) ծրագրավորման անփութության դեպքում։

Ավտոմատ զանգվածները (տեղադրվում են կոմպիլյատորի կողմից) ստեղծվում են ենթածրագրի կանչման ժամանակ և նրա տեղական օբյեկտներն են։ Նրանց սահմանները որոշվում են ամեն անգամ ընթացակարգին դիմելու ժամանակ։ Ընդ որում, դրանից դուրս գալու դեպքում դրանք ոչնչացվում են, իսկ հիշողությունը՝ մաքրվում։ Ավտոմատ arrays ընթացքում ծրագրի կատարման են դեղ տեղադրված (օգտագործելով ALLOCATE օպերատորի) - ի կույտ։

Ֆորտրանի ցուցիչները նման են Si-ի ցուցիչներին, սակայն հաշվարկային խնդիրների լուծման և մաթեմատիկական ալգորիթմների մշակման ժամանակ դրանք մեծամասամբ հաջողությամբ փոխարինվում են Ֆորտրանի այլ գործիքներով։

### Վերահսկիչ կառույցներ
F'90 ստանդարտից սկսած, եԹԵ ԱՆՎԱՐ - ELSEIF THEN - ԵՐԿՐՈՐԴ ԵԹԵ, պայմանական մասնաճյուղային կոնստրուկցիան չի տարբերվում այլ ժամանակակից լեզուների նման կոնստրուկցիաներից և փոխարինեց այսպես կոչված «Թվաբանություն» ԵԹԵ պիտակներով, արժեզրկված։ Պայմանական հայտարարության ավելի պարզ ձև կա։ ԵԹԵ (տրամաբանական պայման) հայտարարություն, որտեղ կատարված հայտարարությունը պետք է եզակի լինի IF հայտարարությունից հետո, օրինակ՝ Goto պիտակը։
```fortran
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
```
Եթե արժեքը փոփոխական N, որը կոչվում է արտահայտություն ընտրության, համընկնում է ցուցակի selectors (ցանկ արժեքների կամ տիրույթում) է K-կամ CASE օպերատորի, օրինակ, երրորդ համար N = 70, ապա, կատարելուց հետո համապատասխան բլոկ-3 օպերատորների միավորի, արդյունք է նախագծման SELECT CASE, և ընդհատումը օպերատորների (տեսակը BREAK) չի պահանջվում։ Case DEFAULT օպերատորը, ինչպես նաև նախագծման անունը, Անհրաժեշտ չէ։ Միջակայքերը տարբեր CASE օպերատորների ընտրիչների ցուցակներում չպետք է համընկնեն կամ ունենան առնվազն մեկ ընդհանուր տարր։

Որպես ընտրության արտահայտություն (N) կարող է լինել ամբողջ զանգվածի տարր։

Ընտրողների ցուցակների միջակայքերը տարածվում են միայն ամբողջ թվերի կամ նիշերի համար՝ վերևից բարձրանալով վերին սահմաններից. նիշերի համար `իրենց ծածկագրերի աճման կարգով։

Ժամանակակից Ֆորտրանայում գոյություն ունեն կրկնորինակման  կոնտերների ցիկլերի երկու ձև՝  ավանդական DO—ENDDO դիզայն  և  հանգույց պիտակի հետ։ Վերջինս ճանաչվել է հնացած կառույց, սկսած ստանդարտ F՝ 90, սակայն մինչ օրս մտնում է ստանդարտներ։ Հանգույցների համար  վերջին ձևը կարող է լինել շատ ավելի հակիրճ։
```fortran
!Նախորդ ցիկլի կառուցվածքի շարահյուսություն
    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
```
Ցիկլի վերնագիր հետ կոնտեներն  ունի հետևյալ ամբողջական տեսքը։
```fortran
name: DO I=N1, N2, dN  ! նախագծման անունը ընտրովի
...                    !N1 - հաշվիչի սկզբնական արժեքը, N2 - վերջնական, dN - քայլ (ցիկլի պարամետրեր)
      END DO name      !  Ցիկլի պարամետրերը կամայական նշանի ամբողջ թվեր են։ dN- ն հավասար չէ զրոյի։
```
Ցիկլի մարմնի կատարման թիվը, առանց ընդհատումների, հավասար է  *N<sub>с</sub>*=`max`(`int`*((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։*

Հնարավոր է նաև մի հանգույց, որի ցիկլը՝ DO WHILE(տրամաբանական պայման) — END DO պայմանով, և do — END do անվերջ ցիկլը, որոնք ունեն ստանդարտ ձև։

Ցիկլ օպերատորը ցիկլի անունը ընդհատում է ընթացիկ ցիկլ բազմակրկնություն և անցնում է հաջորդ բազմակրկնություն նույն ցիկլի։ Եթե ցիկլի անունը նշված չէ, ապա կատարվում է ընթացիկ ցիկլի բազմակրկնության ընդհատումը (որտեղ գտնվում է CYCLE օպերատորը)։

EXIT հայտարարության հանգույցի անվանումը ընդհատում է հանգույցի կատարումը նշված անվանմամբ և հետագայում փոխանցում հսկողությունը, իսկ եթե անուն չկա, ապա այն դադարեցնում է ընթացիկ հանգույցը (որի մեջ տեղադրված է EXIT- ի հայտարարությունը)։

CYCLE և EXIT օպերատորները տրամաբանորեն նույնական են GOTO օպերատորին (համապատասխան հանգամանքներում), սակայն զգալիորեն հեշտացնում են ծրագրավորող կոդի ըմբռնումը և սպասարկումը։

## Կազմիչներ
Քանի որ նախնական լեզվի զարգացման կոմպիլյատորներ Fortran արտադրում IBM ընկերությունը։ Ներկայումս IBM ընկերության կողմից մատակարարվում է VS Fortran օպտիմալացնող կոմպիլյատոր IBM System Z mainframe-ի համար, որի տարբեր տարբերակների զարգացման պատմությունը սկսվում է դեռևս 1964 թվականին, ինչպես նաև PowerPC — AIX, Linux և Blue Gene ճարտարապետության վրա հիմնված պլատֆորմների համար XL Fortran կոմպիլյատորը (թողարկվել է նաև macOS տարբերակը, երբ Macintosh համակարգիչներն օգտագործել են PowerPC պրոցեսորները)։ Այս երկու կոմպիլյատորները պարունակում են շատ բարդ օպտիմիզատորներ, որոնք կես դար շարունակ IBM մասնագետների գիտական աշխատանքի արդյունք են։ IBM Fortran XL կոմպիլյատորի հիման վրա Absoft ընկերությունը, IBM-ի բիզնես գործընկերը, ստեղծվել և մատակարարվում է Absoft Pro Fortran կոմպիլյատորը PowerPC (Linux, macOS) և Intel (Linux, macOS, Windows) պրոցեսորների վրա հիմնված համակարգերի համար։

Մինչև 1997 թվականը Windows օպերացիոն համակարգի համար Ֆորտան կոմպիլյատորի խոշոր արտադրողը «Microsoft» կորպորացիան էր։ Հետագայում նա հրաժարվել է դրանց մշակումից՝ ցածր շահութաբերության պատճառով։ Դրանից հետո կոմպիլյատորը մատակարարել է «Dec» ընկերությունը, որը 1998 թվականին մտել է «Compaq»- ի կազմի մեջ և վերջինիս հետ միասին 2002 թվականին միաձուլվել է «HP»- ի հետ։ Կոմպիլյատորի այս տարբերակի հետագա մշակմամբ սկսել է զբաղվել Intel ընկերությունը, իսկ կոմպիլյատորը կոչվում է Intel Fortran Compiler, որը թույլ է տալիս օպտիմալացնել կոդը Intel IA-32, x86_64 և IA-64 հարթակների տակ։

«DEC» ընկերությունը մատակարարում է կոմպիլյատոր, որը ինտեգրված է Microsoft Visual Studio-ի վրա հիմնված Digital Visual Fortran զարգացման միջավայրին։ Այս շարքի ամենահայտնի արտադրանքը FPS 4.0-ն է (Microsoft Fortran Power Station), DVF 5.0-ը և 6.0-ը։ Յուրաքանչյուր Կազմողի կարող է աջակցել մի քանի չափանիշների Ֆորտրան։ Ընկերությունների միաձուլումը պատճառ է դարձել, որ հետագա արտադրանքը հայտնվել է շուկայում Compaq-ի և HP-ի ապրանքային նշանների ներքո։ Ներկայումս HP-ն վաճառում է 6.6 տարբերակի զարգացման միջավայրը Intel/win32-ի համար։ Fortran-ի աջակցությունը իրականացվում է նաև HP-ի բոլոր բարձր կատարողական հարթակների համար։

Ֆորտրանի զարգացման համակարգերի մեկ այլ խոշոր մատակարարը «Lahey»ընկերությունն է, որն առաջարկում է ինտեգրված լուծումներ Windows-ի և Linux-ի համար։

Երկար ժամանակ PC-ի համար Ֆորտրանի լավագույն կոմպիլյատոր էր համարվում «Watcom» ընկերության կոմպիլյատորը, որն առանձնացվել էր Open Watcom առանձին նախագծում, որը զարգացնում է կոմպիլյատորը բաց հիմքի վրա։

Fortran-ի անվճար կոմպիլյատորների շարքում պետք է առանձնացնել նախկին Sun Microsystems-ի (այժմ Oracle) կոմպիլյատորը, որը մտնում է Sun Studio-ի կազմի մեջ, որը SPARC, x86 և x86-64-ի ներքո արդյունավետ կոդ է առաջացնում և հասանելի է Solaris, OpenSolaris և Լինուքսի համար։

GNU-ի ազատ ծրագրային Հիմնադրամը թողարկել է Fortran-77 G77 բաց կոմպիլյատորը, որը հասանելի է գրեթե ցանկացած հարթակի համար և լիովին համատեղելի է GCC-ի հետ։ Այժմ նրան փոխարինելու է եկել gfortran կոմպիլյատորը, որտեղ իրականացվել են Ֆորտրան-95 ստանդարտի գրեթե բոլոր կոնստրուկցիաները և Ֆորտրան-2003, Ֆորտրան-2008 և Ֆորտրան-2018 ստանդարտների բազմաթիվ նմուշներ։ Այն նաև լիովին հակառակ համատեղելի է Fortran-77։ Կա նաև մի անկախ g95 նախագիծ է ստեղծել հիման վրա GCC Կազմողի Fortran-95։

## Փոխգործակցություն այլ լեզուների հետ
Ծրագրավորման շատ համակարգեր թույլ են տալիս կազմել Fortran ծրագիրը հեռարձակելու արդյունքում ստացված օբյեկտային ֆայլեր այլ լեզուներից կազմողներից ստացված օբյեկտային ֆայլերով, ինչը թույլ է տալիս ստեղծել ավելի ճկուն և բազմաֆունկցիոնալ ծրագրեր։ Ֆորտրան ունի նաև մեծ թվով գրադարաններ, որոնք պարունակում են ինչպես դասական հաշվարկային խնդիրների լուծման ռեժիմներ (LAPACK, IMSL, BLAS), բաշխված հաշվարկների կազմակերպման խնդիրներ (MPI, PVM), այնպես էլ գրաֆիկական ինտերֆեյսերի կառուցման (Quickwin, FORTRAN / TK)կամ մուտք գործել ենթաօրենսդրական դաշտ (Oracle):

## Ֆորտրանը ԽՍՀՄ-ում
Ֆորտանը ԽՍՀՄ-ում հայտնվեց ավելի ուշ, քան Արևմուտքում, քանի որ սկզբում ԽՍՀՄ-ում ավելի հեռանկարային լեզու էր համարվում Ալգոլը։ Ֆորտրանի ներդրման գործում մեծ դեր է խաղացել խորհրդային ֆիզիկոսների շփումը CERN-ի իր գործընկերների հետ, որտեղ 1960-ականներին գրեթե բոլոր հաշվարկները կատարվել են Ֆորտրանի վրա ծրագրերի օգտագործմամբ։

Ֆորտրանի առաջին խորհրդային կոմպիլյատորը ստեղծվել է 1967 թվականին Մինսկ-2 մեքենայի համար, սակայն այն մեծ ճանաչում չի ստացել։ Ֆորտրանի լայն ներդրումը սկսվել է 1968 թվականին ԲԵՍՄ-6 մեքենայի համար ՖՈՐՏՐԱՆ-ԴՈՒԲՆԻ կոմպիլյատորի ստեղծումից հետո։ Ֆորտրանի հիմնական լեզուն ԱՍՎՏ և տես ԷՎՄ, հաճախ օգտագործվում է ՌԱՏՖՈՐ-ի հետ։ Տես ԷՀՄ մեքենաները, որոնք հայտնվել են 1972 թվականին, ի սկզբանե ունեցել են Ֆորտրանի հեռարձակիչը («փոխառված» IBM/360-ի հետ՝ այլ ծրագրային ապահովման հետ միասին)։

1970-ական թվականներին ԱԳՄ-ում մշակվել է ԳՐԱՖՈՐԻ գրաֆիկական գրադարան («Ֆորտրանի գրաֆիկական ընդլայնում»)։

1980-ականների վերջից-1990-ականների սկզբին ֆիզիկոս Անդրեյ Զարեցկին ստեղծեց մանկական գրքերի շարք, որոնց գլխավոր հերոսներից մեկը պրոֆեսոր Ֆորտրանն էր, որը երեխաներին մատչելի լեզվով բացատրեց համակարգչային գրագիտության և ծրագրավորման հիմունքները։

## Ծանոթագրություններ

## Գրականություն
* 
* 
* ISO/IEC 1539-1:2010 Information technology — Programming languages — Fortran — Part 1: Base language
* ISO/IEC 1539-2:2000 Information technology — Programming languages — Fortran — Part 2: Varying length character strings

## Արտաքին հղումներ
* Professional Programmer's Guide to Fortran77 
* GNU Fortran — Կոմպիլյատոր Ֆորտրան 95/2003/2008, GNU կոմպիլյատորների հավաքածուի մի մասը 

Կատեգորիա:Օբյեկտ կողմնորոշված ծրագրավորման լեզուներ
Կատեգորիա:Ամերիկյան հայտնագործություններ