Fortran

Fortran
Szemantika kötelező , párhuzamos
Nyelvóra procedurális , moduláris , objektumorientált programozás elemeivel
A végrehajtás típusa összeállított
Megjelent 1957
Szerző John Backus , IBM
Fejlesztő IBM [1] és John Backus [1]
Fájlkiterjesztés _ .for .f .f90 .f95
Kiadás Fortran 2018 (ISO/IEC 1539-1:2018) (2018. november 28.)
Típusrendszer szigorú , statikus
Főbb megvalósítások GFortran , Open Watcom , Sun Studio , XL Fortran , Intel Fortran
Dialektusok Nagy teljesítményű Fortran
Befolyásolva Gyorskódolás [d]
befolyásolta ALGOL 68 , BASIC , PL/I
Weboldal fortran-lang.org _ 
 Médiafájlok a Wikimedia Commons oldalon

A Fortran ( eng.  Fortran ) az első olyan magas szintű programozási nyelv , amely gyakorlati alkalmazást kapott, van fordítója és továbbfejlesztett [2] . 1954 és 1957 között hozta létre az IBM Corporation programozóinak egy csoportja, John Backus vezetésével [3] . A Fortran név a FOR mula TRAN slator (képletfordító) [4] rövidítése . A Fortran elsősorban tudományos és mérnöki számítástechnikai célokra használatos. A modern Fortran egyik előnye a ráírt nagyszámú program és szubrutin könyvtár [5] .

A Fortranban számos különféle matematikai könyvtár létezik (főleg a nyelv régebbi verzióiban) mátrixalgebrához és lineáris egyenletrendszerek megoldásához , könyvtárak differenciálegyenletek megoldására , integrálegyenletek és rendszereik, függvények közelítése , speciális függvények , gyors Fourier-transzformációk , matematikai statisztika és egyéb matematikai tudományágak. Ezeket a könyvtárakat általában a fordítóval együtt szállítjuk. Számos ilyen csomagot hoztak létre az évtizedek során, és a mai napig népszerűek a tudományos közösségben, például az International Mathematical Subroutine Library (IMSL) [6] [7] .

A legtöbb ilyen könyvtár valójában az emberiség tulajdona: forráskódban érhetők el, jól dokumentálva, hibakeresve és nagyon hatékonyan.

A Modern Fortran (Fortran 95 és Fortran 2003) megszerezte az új számítástechnikai architektúrák hatékony programozásához szükséges szolgáltatásokat; lehetővé teszi a modern programozási technológiák alkalmazását, különösen az általános és moduláris programozást , az OOP -t, miközben fenntartja a folytonosságot a korábbi verziókkal. A modern Fortran fejlesztésének egyik fő koncepciója a párhuzamosság támogatása és a vektoros műveletek [8] .

A nyelvi szabványok fejlődése

A Fortran egy erősen szabványosított nyelv, így könnyen portolható különböző platformokra. Az új nyelvi szabványok nagyrészt megőrzik a folytonosságot a régebbiekkel, ami lehetővé teszi a korábban írt programok kódjainak használatát és módosítását [8] . Ugyanakkor a nyelv fejlődésével előre bejelentik az elavult konstrukciókat, amelyek a jövőben eltávolíthatók [9] .

FORTRAN 66 (1966)

Az ANSI X3.9-1966 szabvány [10] meghatározta a FORTRAN nyelvet (a de facto szabványként szolgáló IBM FORTRAN IV-en alapul). Később FORTRAN 66-ként emlegették, bár sokan továbbra is FORTRAN IV-nek nevezték, amely nyelven a szabvány nagyrészt alapult.

FORTRAN 77 (1978)

ANSI X3.9-1978, ISO 1539:1980 [11] , számos fejlesztés [8] :
  1. Operátorok fájl megnyitásához és bezárásához ( OPEN, CLOSE) és szabványos eszközre történő kimenethez - PRINT.
  2. Hozzáadott karakterlánc adattípus és funkciók a feldolgozásához.
  3.  Bemutatjuk a blokk operátort IF és a konstrukciót IF THEN , valamint a programtöredék-befoglalás operátort .ELSE IF THENEND IFINCLUDE
  4. Bevezette a közvetlen hozzáférésű fájlokkal való munkavégzés lehetőségét.
  5. A tömb maximális mérete 3-ról 7-re nőtt. A tömbindexekre vonatkozó korlátozások megszűntek.
  6. Javultak, bővültek az eljárásokkal való munkavégzés lehetőségei.
  7. Bevezették a belső fájl fogalmát (amelyek tömbök, numerikus és karakterlánc-változók). A belső fájlok különösen lehetővé teszik szám-karakterlánc és karakterlánc-szám konverzió végrehajtását szabványos olvasási és írási operátorokkal READés WRITE[12] .

Fortran 90 (1991)

Az ISO/IEC 1539:1991 (ANSI INCITS 198-1992) [13] jelentősen átdolgozta a nyelvi szabványt [12] , beleértve a FORTRAN nevét Fortranra.
  1. Bevezetett egy ingyenes formátumot a kódíráshoz. További leírások jelentek meg IMPLICIT NONE, TYPE, ALLOCATABLE, POINTER, TARGET, NAMELIST.
  2. Bemutatjuk a vezérlő operátorokat és konstrukciókat. Hozzáadva DO… END DO(a hurok címkével történő lezárása helyett), DO WHILE, vezérlő átviteli operátor a hurok elejére CYCLE, kiválasztási konstrukció SELECT CASE(a nehézkes konstrukciók IFés operátorok helyettesítésére GOTO), valamint egy programegység, modul vagy belső eljárás végső operátora END[8] .
  3. Mutatóeszközök és funkciók bevezetése a RAM-mal való munkához (a C nyelv analógiájára).
  4. Bevezetésre kerültek a dinamikus memóriával való munkavégzésre szolgáló operátorok ( ALLOCATE, DEALLOCATE, NULLIFY).
  5. Hozzáadott szoftverösszetevők MODULE, PRIVATE, PUBLIC, CONTAINS, INTERFACE, USE, INTENT.
  6. Bevezetésre került a tömb hozzárendelésének maszkolása (hozzárendelés, amikor a tömbelemekre szabott logikai feltétel teljesül feltételes operátorok használata nélkül), valamint a tömbszakaszokkal való munka. Bevezetésre kerül a ciklusok részleges cseréjére szolgáló operátor és konstrukció WHERE(a hozzárendelési operátor jobb oldala nem változik). A hozzárendelés maszkolása szinte minden tömbön működő operátorra, konstrukcióra és függvényre vonatkozik.
  7. A szabványos hozzárendelés, összeadás, kivonás, valamint számmal való osztás és szorzás műveletei kiterjesztésre kerülnek a tömbökre és a szakaszok által meghatározott szakaszaira. Ebben az esetben elemenkénti hozzárendelés történik.
  8. Új beépített funkciók vannak, elsősorban a tömbökkel való munkához. Függvények tömbökben történő számításokhoz: ALL(logikai szorzat) és MASK(logikai összeadás), COUNT(igaz elemek száma), PRODUCT(tömbelemek szorzata), SUM(tömbelemek összeadása), DOT_PRODUCT(skaláris szorzat), MATMUL(mátrixszorzás). Súgó funkciók kerültek hozzáadásra, valamint a tömbök átformálásának és hajtogatásának funkciói.
  9. OOP elemek jelentek meg a nyelvben [14] . Származtatott adattípusok bevezetése. Külön bejelentették a jövőben eltávolítandó, elavult nyelvi funkciók listáját.
  10. A karakterláncadatok kezeléséhez további funkciók kerültek hozzáadásra, különösen a TRIM(végszóköz eltávolítása) és REPEAT(egy karakterlánc többszöri másolata) és a balra és jobbra igazítási funkciók.

Fortran 95 (1997)

ISO/IEC 1539-1:1997 [15] , a korábbi szabvány átdolgozása. Bemutatjuk az operátort és a konstrukciót FORALL, amelyek nagyobb rugalmasságot tesznek lehetővé, mint az operátor és a konstrukció WHEREa tömbök hozzárendeléséhez és a nehézkes hurkok helyettesítéséhez. FORALLlehetővé teszi a szakaszok vagy operátorok bármilyen hozzárendelésének cseréjét és az építést WHERE, különösen hozzáférést biztosít a mátrix átlójához. Ezt az operátort ígéretesnek tartják a párhuzamos számításokban, ami a huroknál hatékonyabb párhuzamosításhoz járul hozzá [16] [12] [17] .

Fortran 2003 (2004)

Az ISO/IEC 1539-1:2004 [18] szabvány szerint elfogadva . Az OOP támogatás további fejlesztése a nyelvben. Interakció az operációs rendszerrel. A következő szolgáltatások is hozzáadásra kerültek [8] :
  1. Aszinkron adatbevitel-kimenet.
  2. A C nyelvvel való interakció eszközei .
  3. A dinamikus adatelhelyezés javítása [17] .

Fortran 2008 (2010)

ISO/IEC 1539-1:2010, a Fortran 2008 közönséges informális neve [19] . A szabvány a párhuzamos számítási nyelv (Co-Arrays Fortran) támogatását feltételezi [8] [20] . Tervezik továbbá a tömbök maximális méretének 15-re növelését, beépített speciális matematikai függvények hozzáadását [8] stb.

Fortran 2018

A Fortran 2018 nyelv legújabb verziója (korábbi nevén Fortran 2015) 2018. november 28-án jelent meg [21] . A Fortran 2018 (ISO/IEC 1539-1:2018) a következőket tartalmazza: Valamint az ISO/IEC/IEEE 60559:2011 , a hexadecimális lebegőpontos bemenet/kimenet, az IMPLICIT NONE fejlesztések és egyéb változtatások támogatása.

A nyelv jellemzői és jellemzői

A Fortran beépített matematikai függvények széles készletével rendelkezik, támogatja az egész, valós és komplex számokkal való munkát dupla és nagy pontossággal (bináris műveletekhez használják real(10)), gazdag eszközkészlettel rendelkezik a tömbök és külső fájlokkal való munkavégzéshez. A modern Fortran (2003 és újabb) teljes eszközkészlettel rendelkezik a karakteradatok kezeléséhez.

Kezdetben a nyelv kifejezőeszközei nem voltak túl nagyok, mivel a Fortran volt az első magas szintű nyelv, amelyet implementáltak. Később a Fortran számos lexikális konstrukcióval bővült, amelyek a strukturális, moduláris, általánosított és objektum-orientált programozásra jellemzőek.

Kódjelölési formátum

A programok felépítése eredetileg a lyukkártyákról származó bevitelre összpontosított, és számos olyan tulajdonsággal rendelkezett, amelyek ebben az esetben kényelmesek voltak. Tehát az 1. oszloptól az 5. oszlopig volt egy címketerület, a 6. az előző sor folytatásaként szolgált a szöveg megjelölésére (bármilyen karakter, kivéve a szóközt és a "0"-t), a 7-től a 72. A tényleges szöveg operátor vagy megjegyzés található. A 73-tól 80-ig terjedő oszlopok szolgálhattak kártyaszámozásra (a véletlenül szétszórt pakli visszaállítására), vagy rövid megjegyzésre, ezeket figyelmen kívül hagyta a fordító. Ha az operátor szövege nem fért be a kijelölt helyre (7. oszloptól 72. oszlopig), akkor a következő sor 6. oszlopába egy folytatási tábla került, majd az operátor azon folytatta. Két vagy több operátort nem lehetett egy sorban (térképen) elhelyezni. Amikor a lyukkártyák történelemmé váltak, ezek az előnyök komoly kellemetlenségeket okoztak.

Ez az oka annak, hogy a Fortran szabvány a Fortran 90-től kezdve, a forrásszöveg rögzített formátumának megőrzése mellett, bekerült a szabad formátumba , amely nem szabályozza a sor helyzetét, és lehetővé teszi, hogy soronként egynél több utasítást írjon. A szabad formátum és a strukturált programozás modern módszereinek bevezetése [8] lehetővé tette olyan kódok létrehozását, amelyek olvashatósága és áttekinthetősége nem rosszabb, mint más modern programozási nyelvekkel, például Pascal , C vagy Java . A modern fejlesztői környezetek lehetővé teszik a formátumok kombinálását: például a karakterlánc hosszát szabad formátumra bővíteni (általában 132 karakter), soronként több utasítás írását, ugyanakkor a bal behúzás megtartását is lehetővé teszi. (bal margó készítése), a régi rögzített formátumra jellemző, a hibajeleknek és formátumoknak leginkább dedikált oszlopot, valamint egy sorfolytatót hagyva meg.

A régi Fortran egyfajta "hívókártyája" egy hatalmas számú címke, amelyeket feltétel nélküli ugrás GOTOoperátorokban, hurokoperátorokban, feltételes operátorokban és formátum bemeneti-kimeneti leíró operátorokban használtak FORMAT. A címkék és kijelentések nagy száma GOTOgyakran megnehezítette a Fortran programok megértését.

Ez a negatív tapasztalat az oka annak, hogy számos modern programozási nyelvben (például a Java nyelvben ) a címkéket és a hozzájuk tartozó feltétel nélküli ugrásoperátorokat jelentősen módosították.

A modern Fortran azonban (főleg a Fortran'90-es verziótól kezdődően) megszabadul a címkék feleslegétől az olyan operátorok bevezetése miatt, mint a DO… END DO, DO WHILE, SELECT CASE, konstrukciók IF THEN- ELSEIF THEN- ELSE- END IF, stb. Ráadásul a modern nyelvi szabványokban csak a klasszikus GOTOa mai napig számos nyelven használt operátor . A számítógépes operátort GOTO, valamint az ENTRY eljárások többszöri bevitelét tartalmazó konstrukciót kihagyták a szabványból, bár a fordítók általában még mindig támogatják őket.

Helló Világ!

Rögzített formátum (az 1-től 6-ig terjedő sorok szóközei "␣" karakterekkel vannak jelölve):

␣␣␣␣␣␣ NYOMTATÁS * , 'Hello, World!' ␣␣␣␣␣␣ VÉGE

Szabad formátum:

print * , "Hello, World!" vége Megjegyzések.
  • A fő programindítási utasítás PROGRAMnem kötelező. Szigorúan véve, az egyetlen kötelező utasítás a Fortran programban a END.
  • A programutasítások írásakor a kis- vagy nagybetűk kiválasztása tetszőleges. A modern Fortran nyelvi szabványokat tekintve sok nagybetű és sok kisbetű azonos.

Adattípusok

A Fortran 5 alapvető elemi beépített adattípust támogat: valós ( REAL) , összetett ( COMPLEX) , egész szám ( INTEGER) előjellel vagy anélkül, logikai ( LOGICAL) és karakter ( CHARACTER) . Lehetőség van származtatott adattípusok létrehozására is a TYPE. A nyelv létrehozásának kezdetétől fogva 4 adattípus volt: valós, összetett, egész és logikai.

Van egyfajta adattípus vagy típusparaméter fogalma . Ez lehetővé teszi a valós és összetett adatok paraméterezését (azaz a tizedes sorrend pontosságának és tartományának megadását), valamint egyéb adatok paraméterezését, növelve az alkalmazások hordozhatóságát.

Minden numerikus adat esetében a szokásos aritmetikai műveletek és hozzárendelések vannak definiálva, és vannak beépített függvények. Egy beépített függvény csak valós vagy komplex számot ( nem egész számot ) vehet fel argumentumként .Log(x)x

Általános szabály, hogy „egyetlen” precíziós valós számokhoz 4 bájt van lefoglalva ( REAL(4), vagy típusvariációs paraméter KIND=4), „dupla” - 8 bájt. Komplex számok esetén a bájtok száma megduplázódik.

Az egész számok 1 és 4 bájt közöttiek lehetnek. A modern fordítók lehetővé teszik a programozó számára, hogy számokkal és "négyszeres" pontossággal működjön.

Az aritmetikai műveleteknél a típus alapértelmezés szerint egész számról valós, majd komplex számra, vagy egy speciális beépített numerikus függvény segítségével módosul. Tehát a következő kifejezések egyenértékűek ( i  egy egész szám): és . Log(i*1.)Log(real(i))

A karakterlánc (karakter) adatok hossza zárójelben van megadva, akár a type attribútum, akár a karakterlánc neve után. Egy karakterlánc megadásához a programtörzsben egyszeres vagy dupla idézőjeleket használunk. Tehát a bejegyzések egyenértékűek: A='forró' vagy A="forró" . Ez akkor hasznos, ha magában a karakterláncban idézőjelek vannak: B="It isn't hot" .

A karakterláncokhoz van beépített karakterlánc-összefűzési (összeadási) művelet: //. 17 speciális beépített függvény található a karakteradatokhoz (az általánosak mellett, amelyek minden típusú adatot kezelnek).

A címkék  5 számjegynél nem hosszabb egész számok; karakterek nem megengedettek. A címkéket utasításokban GO TO, olvasási, írási és formázási utasításokban, valamint hiba- és kivételkezelésben használják. A címkéken kívül a Fortran képes elnevezni vezérlőstruktúrákat (hurkok, logikai feltételek, struktúrák FORALL... END FORALL, WHERE... END WHERE, SELECT CASE... END SELECT, TYPE... END TYPEstb.), és a struktúra neve bármilyen karaktert tartalmazhat változónevekben megengedett.

Beépített funkciók karakteradatokhoz

Szám-karakter konverzióhoz : CHAR(i)és ACHAR(i). Konvertálja az egész számot a megfelelő operációs rendszer karakterévé vagy ASCII -tábla karakterévé .

Karakter-szám konverzióhoz : ICHAR(i)és IACHAR(i). Végezzen fordított transzformációkat.

Karakterlánc-összehasonlító függvények : LGE(A,B), LGT(A,B), LLE(A,B)és LLT(A,B). A függvények eredménye "igaz", ha az ASCII karakterekben kifejezett karakterlánchosszak ( L(A) és L(B) ) kielégítik a következő egyenlőtlenségeket: L(A) L(B), L(A) L(B), L(A) L(B) és L(A) L(B) .

Hosszfüggvények : LEN(A)és LEN_TRIM(A). Az első az A karakterlánc hosszát ( karakterek számát), a második a karakterlánc hosszát adja vissza szóközök nélkül, ha vannak ilyenek.

Konverziós függvények : TRIM(A), ADJUSTL(A)és ADJUSTR(A), REPEAT(A,N). A függvény az ATRIM(A) karakterláncot szóközök nélkül adja vissza. A és függvények egy karakterláncot balra és jobbra igazítanak (eltávolítják a szóközöket). A függvény az A karakterlánc N példányát adja vissza .ADJUSTL(A)ADJUSTR(A)REPEAT(A,N)

Sorkereső funkciók: , , . Az opcionális back paraméter határozza meg a keresés irányát: alapértelmezés szerint balra (for ) jobbra (for ). SCAN(A,B,[back])INDEX(A,B,[back])VERIFY(A,B,[back])back=.false.back=.true.

A függvény meghatározza a B karakterlánc-lista első megtalált karakterének SCANpozíciószámát az A karakterláncban (balra vagy jobbra) . Ha az eredmény negatív, akkor a függvény 0 egész számot ad vissza. A függvény meghatározza annak a pozíciónak a számát, ahonnan a B karakterlánc teljes előfordulása az A karakterláncban először kezdődik . Sőt, a keresés a bal és a jobb oldalon is végrehajtható, de a pozíciószámot mindig a bal oldalon, a sor elejétől számítjuk. Ha a keresés sikertelen, a függvény 0-t ad vissza. A függvény fordítottja a függvénynek . Így egy ilyen karakter pozíciószámát adja vissza az A karakterláncban , amely nem szerepel a B maszk karakterláncban . Ha az A karakterlánc összes (különböző) karaktere megtalálható a B maszkkarakterláncban, akkor a függvény 0-t ad vissza. INDEXVERIFY INDEXVERIFY

Ezek a függvények mindegyike elemi, és argumentuma lehet karakterekből vagy egész számokból álló tömb. Az eredmény egy illesztett numerikus, karakteres vagy logikai tömb lesz.

A Fortran szabványok a 2003-as verziótól kezdve lehetővé teszik a Unicode karakterekkel való munkát .

Ezen funkciók mellett a Fortran lehetővé teszi a szimbolikus adatok feldolgozását a beépített mátrix (vektor) elemzés segítségével, ami jelentősen növeli a szimbolikus adatok feldolgozásának rugalmasságát.

A Fortranban a C nyelven írt programokkal való kompatibilitás érdekében létezik a C-string fogalma , amelyet az idézőjel után egy karakter hozzáadásával határozunk meg: A='Ez egy C-string'c . A null karakterlánc így lesz megadva: A='\0'c .

Alprogramok (eljárások és funkciók)

A Fortran szubrutinjai a legelső szabvány óta léteznek, és még mindig az egyik fő programozási eszköz [8] .

A Fortranban a szubrutinok, függvények meghívása és paramétereik átadása kizárólag hivatkozással történik (és nem érték alapján ). Ezért az alprogram megváltoztathatja a neki átadott argumentumot a fő programban, ha ez nincs kifejezetten megakadályozva. Egy ilyen mechanizmus lehetővé teszi a jelölés természetessé tételét matematikai képletek írásakor, és ugyanakkor magas teljesítmény fenntartását nagy adattömbökkel végzett munka során [24] .

A Fortran szubrutinok a paraméterlistában (úgynevezett formális paraméterek) és opcionális (opcionális) paramétereket tartalmazhatnak, vagy egyáltalán nem tartalmazhatnak paramétereket.

A nyelvi szabvány lehetővé teszi az eljárások és műveletek túlterhelését egy általános interfészen keresztül, amely különböző eljárásokat kombinál (mindegyik például egész számokkal, valós számokkal, komplex számokkal és karakterváltozókkal működik) egyetlen (általános) név alatt. Ebben az esetben elegendő az általános eljárásra hivatkozni a fő programban, és az elvégzett műveletek jellege attól függ, hogy milyen adattípust kínálnak a feldolgozásra. Minden beépített függvény és szubrutin ennek az elvnek megfelelően készül, például COS(x). Az eljárások, funkciók és operátorok túlterhelése (sőt, a programozó a túlterhelt operátorok saját szimbólumait is felajánlhatja a beépítetteken kívül) nemcsak a beépített adattípusokra vonatkozik, hanem a programozó által meghatározott típusokra is [12] .

Alprogramok típusai

Az eljárások alprogramokra és függvényekre vannak osztva . Az alprogramok kényelmesebbek, ha nagyszámú heterogén eredményt kell visszaadnia; függvények - ha egy típusú eredményt ad vissza (beleértve a tömböt is).

Subroutine Az alprogramot az alprogram_neve (formális argumentumok listája) leíró operátor határozza meg , a függvényt a függvénynév operátor Function (formális argumentumok listája) .

Egy szubrutint a Call szubrutin_neve (a tényleges argumentumok listája) utasítással hívunk meg . A függvényeket név szerint hívják meg, a tényleges argumentumok listájával, speciális operátor használata nélkül.

Az F'90 szabványtól kezdve a rekurzív eljárások támogatottak (a korábbi verziókban nem érhetők el a korlátozott gépmemória miatt), amelyekhez explicit specifikátor szükséges a deklarációhoz recursive. Ebben az esetben a függvény eredményének el kell térnie magától a függvény nevétől.

A tiszta eljárások és funkciók ( pure subroutine [function]) az F'95 szabvány által bevezetett eljárások és függvények, amelyeknek nincs mellékhatása. A tiszta függvénynek értéket kell visszaadnia, és nem módosíthatja a bemeneti paramétereit és/vagy a globális adatait; intent(outegy tiszta eljárásnak csak azokat a paramétereket kell megváltoztatnia, amelyek a vagy attribútum segítségével kifejezetten eredményként (kimenetként) vannak megadva inout). A mellékhatások lehetősége a Fortranban (vagyis a fő program változóinak szubrutinon keresztüli megváltoztatásának lehetősége) a gyors címtovábbítási módszer mellékhatása.

A tiszta programegységek nem tartalmazhatnak I/O utasításokat ( WRITEés READ) külső fájlokhoz és eszközökhöz, beleértve a billentyűzetet és a képernyőt, valamint a program szüneteltetési és leállítási utasításait.

A Fortran összes beépített funkciója és szubrutinja, beleértve a matematikaiakat is (kivéve azokat, amelyek hozzáférnek az operációs rendszerhez, a dátum- és időfüggvényekhez, valamint a véletlenszám-generátorokhoz) tiszta, azaz nem hoznak létre mellékhatásokat. Tiszta függvényeket vezettek be a programozási kultúra fejlesztése és az algoritmusok párhuzamosításának hatékonyságának növelése érdekében [25] [9] .

Alprogram argumentumok

Az alprogram-argumentumok tetszőleges beépített adattípusok lehetnek, beleértve a tömböket és azok szakaszait, a mutatókat és a programozó által meghatározott típusokat. Az alprogram-argumentumok függvények és egyéb szubrutinok is lehetnek, kivéve a belső szubrutinokat, az operátori függvényeket, az általános (általános) eljárásokat (csak meghatározott nevek megengedettek) és néhány más beépített típust.

Az érveket formálisra és tényszerűre osztják . Az argumentumok a szubrutin neve után zárójelben vannak, és vesszővel elválasztva. A tényleges és formális argumentumok neve megegyezhet.

A formális argumentumok  a leírásában megadott szubrutin (függvény) argumentumai. Ha az alprogramnak nincsenek argumentumai, a zárójelek elhagyhatók. A függvény akkor is tartalmaz zárójeleket, ha nincsenek formális argumentumok. A formális paraméter-eljárást formális eljárásnak nevezzük .

Az aktuális argumentumok  olyan argumentumok, amelyeket egy szubrutinnak vagy függvénynek adnak át, amelyet a meghívásakor végre kell hajtani. Az argumentumok nélküli függvényt üres listával zárójelben, az alprogramot zárójelek nélkül hívjuk meg.

A formális és a tényleges érveknek konzisztensnek kell lenniük . Az argumentumok típusának és megjelenési változatainak meg kell egyeznie, a tömbnek meg kell felelnie egy azonos konfigurációjú tömbnek (vagy egy tömb szakaszának).

Vannak olyan tömbök, amelyek elfogadják a konfigurációt és a méretet az eljárások formális argumentumaként. A konfigurációt átvevő tömb  egy formális tömb argumentum, amely örökli a megfelelő tényleges tömb konfigurációját. Egy ilyen tömb esetében, amikor deklarálják, a dimenzió be van állítva (amely egybeesik az aktuális tömb argumentum dimenziójával), és a felső határok kimaradnak. Alapértelmezés szerint az alsó határ 1, de tetszőlegesen beállítható. A konfigurációt átvevő tömb elemeinek száma és értéke pontosan a tényleges tömb argumentumból öröklődik. A méretet felvevő tömb  egy korábbi, natív Fortran'77 nyelvi mód az öröklődő tömbök leírására, amelyet a kompatibilitás érdekében megtartottak. Az ilyen tömböknél csak az utolsó dimenzió öröklődik, amelynek felső határát egy csillag ( *) írja le. Ebben az esetben a formális és a tényleges tömb-argumentumok eltérő méretűek lehetnek. A konfigurációt és méretet felvevő tömbök nem lehetnek dinamikusak vagy mutatók. A tömböket öröklő eljárásoknak explicit interfésszel kell rendelkezniük.

A formális argumentumkarakterláncok is örökölhetik (átvehetik) a megfelelő tényleges karakterlánc-argumentum hosszát. Azokat a karakterláncokat, amelyek hosszúságot vesznek fel , a következő szimbólummal írjuk le *: Character (Len = *) string_name . Ha kifejezetten megadja egy karakterlánc hosszát, a karakterlánc-formális argumentum hossza nem lehet nagyobb, mint a megfelelő tényleges karakterlánc-argumentum.

Az érvek pozicionálisak és kulcsfontosságúak . A pozicionális formális és tényleges argumentumok az argumentumlistában megjelenő sorrendben kapcsolódnak egymáshoz, aminek meg kell egyeznie. Kulcsszavak  – a kulcs nevével, amely megegyezik a formális argumentum nevével. A kulcsszavak lehetővé teszik az argumentumok sorrendjének megszakítását vagy némelyikük kihagyását. Tehát egy SubroutineONE (A, B, C, D) fejlécű szubrutin esetén a hívás a következő lehet: CallONE (D= Z , C= Y , B= X , A= W ), ahol W, X, Y, Z  a tényleges érvek.

A kulcs argumentumok lehetővé teszik, hogy opcionális argumentumai legyenek, amelyek elhagyhatók. Ebben az esetben az opcionális argumentumoknak a Optional. Például, ha Optional C, DCall meg van adva, akkor ebben az esetben EGY (B= X , A= W ) hívható meg .

Az opcionális paraméterekkel rendelkező eljárásoknak explicit interfésszel kell rendelkezniük.

Munka tömbökkel

A tömbök központi szerepet töltenek be a Fortran filozófiájában. Minden nyelvi konstrukció, adat, programegység, operátor, beépített függvény, ciklus létrejött és jön létre, mindenekelőtt a tömbök hatékony feldolgozására. A Fortran fejlődése során azt az elvet követi, hogy lehetőleg kerülje a tömbök részletes (elemenkénti) leírását és feldolgozását. Ez különösen hatékony többdimenziós tömbök feldolgozásakor (a tömbök maximális mérete az F2008 szabványban 15). A tömbök ilyen nézete nem volt általános a nyelv korai verzióiban; a tömbök általánosított megközelítésének első elemei a FORTRAN77-ben jelentek meg; még fejlődnek.

A tömbök statikusak vagy dinamikusak . A dinamikus elhelyezett és automatikus (szubrutin hívásakor jön létre). A kétdimenziós tömb elemei a Fortranban oszlopokba vannak rendezve , nem sorokba, mint például a C -ben. Így a tömb első indexe változik a leggyorsabban. Ezért a beágyazott ciklusokban lévő tömbök hatékony munkája érdekében a belső ciklusokat bal oldali indexekkel, a külső ciklusokat pedig jobb oldali indexekkel kell indexelni. Alapértelmezés szerint a tömbök bemeneti, kimeneti és inicializálási oszloponként vannak hozzárendelve.

do k = 1 , 10 do j = 1 , 20 do i = 1 , 100 arr ( i , j , k ) = 25 ! jobb brr ( k , j , i ) = 0 ! működőképes, de többször lassabb vége do ; vége do ; vége do

A tömbök nulla méretűek lehetnek (beleértve, ha az alsó korlát meghaladja a felsőt). A tömb határindexei tetszőleges egész számok lehetnek. Az alapértelmezett alsó határ 1.

Valódi , kiosztható :: ArR (:,:,:) ! lefoglalt dinamikus valós tömb deklarációja Egész szám , allokálható :: ArI (:), ArSI ( 2 , 5 ) ! egész szám dinamikus és statikus tömbök Karakter ( 32 ), allokálható :: ArC (:), ArC2 ( 20 ) ! karakterláncok dinamikus tömbje 32 karakter hosszúsággal és egy statikus karakterlánc tömb Kiosztás ( ArR ( - 74 : 0 , 8 , 1 : 3 ), ArI ( 0 ), ArC ( 1 : - 1 )) ! dinamikus tömbök elhelyezése print * , méret ( ArR ), méret ( ArI ), méret ( ArC ), méret ( ArSI ) ! 1800 0 0 10 ArC2 ( 17 )( 5 : 27 ) = 'Ez egy karakterlánc hozzárendelés' ! A 17-es sorszám kerül kiírásra ␣ ␣ ␣ ␣ Ez a␣ hozzárendelése␣ a karakterlánchoz␣ ␣ ␣ ␣ ␣ ... Tömbök, operátorok FORALLés WHERE

A Fortran lehetővé teszi a tömbök hatékony, hurkok nélküli hozzárendelését azáltal, hogy maszkolja a hozzárendelést a WHEREés operátorokkal FORALL, valamint tömbszeletekkel és vektorindexekkel . Minden esetben kezdetben a teljes kifejezés jobb oldala kerül kiértékelésre (minden tömbindex esetén), és csak ezután kerül végrehajtásra a maszktömbnek megfelelő indexek hozzárendelése. Az ezekkel az eszközökkel végzett számítások lehetővé teszik a teljesítmény növelését, és megkönnyítik a fordító számára a program önállóan végrehajtható, azaz párhuzamosítható szakaszainak kiválasztását.

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 / ! vagy valós :: frr1 ( 10 ) = ( / 1 , 2 , 3 , 4 , 4 , 4 , 5 , 5 , 5 , 5 / ) ... arr = 1. ! tömb hozzárendelés (beépített túlterhelés a hozzárendelés operátor számára) arr1 = Sin ( arr ) + arr ! az elemi sin függvényt alkalmazzuk a tömb minden elemére arr2 ( I1 : I2 : 1 , J1 : J2 : 2 , K2 : K1 : - 4 ) = arr1 ( I1 : I2 : 1 , J1 : J2 : 2 , K2 : K1 : - 4 ) ! elem-hozzárendelés 1-es, 2-es és -4-es lépésekben (visszafelé) egy indexhármas által frr = ( / ( J , J = 1 , 100 ) / ) ! egydimenziós tömb hozzárendelése körlistán keresztül Forall ( i = I1 : I2 , j = J1 : J2 , k = K1 : K2 , arr ( i , j , k ) > 0. ) brr ( i , j , k ) = Log ( arr ( i , j , k ) )) ! ciklusok és feltételes állítások és konstrukciók cseréje. Hozzárendelés maszkolása (maszk — 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 ) ! keresztmetszetek bővítése Forall ( i = 1 : 100 ) ! Forall konstrukció több hozzárendelési utasításhoz drr ( i , i ) = 0. ! a mátrix átlójához való hozzáférés err ( i , i , i ) = 1. ! és egy háromdimenziós tömb átlói End Forall

Kevésbé nyilvánvaló műveletek lehetségesek:

V egész szám ( - 2 : 2 , 1 : 5 ) V = átformálás ( forrás = ( / ( i , i = 1 , 25 ) / ), alak = ( / 5 , 5 / )) ! tömb inicializálása sorozatszámokkal a tömbkonstruktor és az újraalakító függvény segítségével print * , V ! A DOS ablakba történő kimenet sorról sorra történik ! 1 2 3 4 5 - 1. oszlop ! 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 ) ! Forgass el egy tömbnyomatot * , V ! A DOS ablakba történő kimenet sorról sorra történik ! 1 2 3 4 5 ! 6 7 8 9 10 ! 11 12 13 14 2 változás a 3. oszlopban 15-ről 2-re ! 16 17 18 19 3 változás a 4. oszlopban 20-ról 3-ra ! 21 22 23 24 25

FORALLAz F'95 szabvány által bevezetett operátor és konstrukció képességei szélesebbek, mint az operátoré és a felépítésé WHERE, azonban az utóbbi, bizonyos logikai elágazási esetekben, lehetővé teszi a kód egyszerűsítését egy alternatíva jelenléte miatt ELSEWHERE, kerüljük a beágyazott feltételes operátorokat és az összetett maszktömböket.

A kezelő és a felépítés FORALLcsak tiszta eljárások és funkciók használatát teszi lehetővé . A hozzárendelés elfedésekor a , operátorokban WHERE, FORALLvalamint a tömbök speciális beépített függvényeiben (például SUM), a logikai tömbmaszk a hozzárendelés előtt kerül kiszámításra, és lehetővé teszi a hurkok lecserélését a bennük lévő logikai feltételekkel, ami elkerüli további munka a mikroprocesszor ág előrejelzőjéhez .

A vektorindex  egy egész szám, egydimenziós tömb, amelynek értékei egy másik tömb indexei. A vektorindexek többdimenziós tömbök tetszőleges szakaszainak létrehozására szolgálnak, és ezek általánosításai. Vektoros indexek használatakor ügyeljen az ismétlődő indexértékekre a hozzárendelési operátor bal oldalán, mivel ebben az esetben egy memóriacellába megpróbálnak esetleg eltérő értékeket írni. Az indexek sorrendje tetszőleges (bár ezt nem szabad túlzásba vinni a teljesítményromlás elkerülése érdekében).

Egész szám vi ( 5 ) / 7 , 7 , 7 , 3 , 8 / , vj ( 4 ) / 1 , 2 , 3 , 10 / ! tömbök inicializálása - vektor indexek Valós arr ( 20 , 20 ), brr ( 10 , 10 ) brr = 0. ; arr = 1. ! vektorindexek az őket használó tömbön belül is megadhatók brr (( / 8 , 6 , 2 , 1 , 4 / ), vj ) = arr ( vi , vj ) ! a vektorindexek méretének meg kell egyeznie a bal és a jobb oldalon, és értékeik nem léphetik túl az őket használó tömbök határait ! a vektor indexek mérete kisebb lehet, mint a működő tömbök mérete Beépített függvények tömbökhöz

A modern Fortran számos speciális beépített funkcióval rendelkezik a numerikus és karakteres tömbök használatához (a fentebb tárgyalt általános módszereken kívül). A függvények argumentumai a numerikus és/vagy karakteres tömb , a logikai tömbmaszk ( ami pl. a feltétel tömb>0 ) és a tömb tömb dimenziója , amely formálódik (ha a dim argumentum adott ) a tömb egy szakasza az egyik dimenzió mentén a dim számmal . A tömb tömbje , hacsak másképp nincs megadva, lehet egész szám, tartalmazhat valós vagy komplex számokat. Ha a maszk tömb nincs megadva, akkor az értéke ugyanúgy igaz. A logikai tömbmaszknak , ha adott, ugyanolyan formájúnak kell lennie, mint a tömbnek , vagy skaláris értékkel kell rendelkeznie . Az F'90 szabvány által bevezetett funkciók nagy része. .TRUE.

ALL(mask[, dim]) egy logikai függvény; "igaz" értéket ad vissza, ha a logikai tömbmaszk minden eleme igaz (az opcionális dim dimenzió mentén ), és ellenkező esetben fordítva.
ANY(mask[, dim]) egy logikai függvény; akkor igaz, ha a logikai tömbmaszk legalább egy eleme igaz (az opcionális dim dimenzió mentén ).
COUNT(mask[, dim]) egy egész függvény; az eredmény megegyezik a maszk tömb valódi elemeinek számával (az opcionális dim dimenzió mentén ).

MAXLOC(array[, mask][, dim])A , MINLOC(array[, mask][, dim]),
 egész szám függvények, amelyek rendre visszaadják a maximális és minimális elem indexét (vagy a maximális és minimális elemek indexét) az opcionális dim dim mentén a maszktömbnek megfelelő elemek esetében. A függvények a tömb első elemének indexét adják vissza . Ha a dim függvény argumentuma nincs megadva, vagy ha a tömb  egydimenziós tömb, akkor az eredmény egy egydimenziós tömbbe kerül.
Többdimenziós tömbök tömb esetén az eredmény egy olyan tömbbe íródik, amelynek a rangja eggyel kisebb, mint a tömb tömb rangja (a dim nincs kizárva ).

Az indexértékek számolása a tömb alsó határától számítva sorrendben történik. Vagyis ha a tömb alsó határának száma eltér egytől, akkor a tömb maximális vagy minimális elemének eléréséhez hozzá kell adni a függvények eredményéhez az alsó határ és az egy index közötti MAXLOCkülönbséget . MINLOC.

MAXVAL(array[, mask][, dim]), MINVAL(array[, mask][, dim]) — keresési függvények a maximális és minimális elemre a tömbtömbben azon elemek számára, amelyek kielégítik a logikai maszk tömbmaszkot az opcionális dim dim mentén . A függvény eredménye azonos típusú és változatú, mint a tömb . A tömb csak valós vagy egész szám lehet.
Egydimenziós tömb esetén, vagy ha nincs dim argumentum , az eredmény egy skalár, ellenkező esetben pedig egy olyan tömb, amelynek rangja eggyel kisebb, mint a tömb rangja .

FINDLOC(array, value[, dim][, mask]) egy egész függvény, amely a tömbelem indexét adja vissza értékkel . Az F2008 szabvány bevezette. A keresett tömbelemek kielégítik a logikai maszk tömbmaszkot az opcionális dim dimenzió mentén . Az érték argumentum típusának meg kell egyeznie a tömb típusával, és bármilyen beépített típus lehet (beleértve az összetettet, a logikai értéket vagy a karaktert). A függvény többi tulajdonságai hasonlóak a és a függvények tulajdonságaihoz . MAXLOCMINLOC

Az F2003 szabványtól kezdve a MAXLOCés függvények MINLOCa függvényhez hasonlóan FINDLOCkarakteradatokon is működnek.

SUM(array[, mask][, dim])és PRODUCT(array[, mask][, dim])elvégzi a tömb elemeinek összegzését, illetve szorzását. A függvényargumentumok jelentése SUMugyanaz PRODUCT, mint a fenti függvényeké.
A funkció PRODUCTaz F2003 szabványtól kezdődően összetett adatokon működik.

DOT_PRODUCT(vector_1, vector_2)az azonos méretű vektor_1 és vektor_2 vektorok (egydimenziós tömbök) lineáris algebra szabályai szerint belső szorzatot hajt végre . A vektor_1 és vektor_2 egydimenziós tömbök bármilyen numerikus és logikai típusú adatokat tartalmazhatnak. A vektor_1 és vektor_2 vektorok egyaránt lehetnek numerikusak, vagy mindkettő logikai érték.

MATMUL(matrix_a, matrix_b) - beépített mátrixszorzó funkció. A lineáris algebra szabályai szerint megszoroz két mátrixot, egy mátrixot egy vektorral, egy vektort egy mátrixszal. A matrix_a és matrix_b függvény argumentumai  kétdimenziós vagy egydimenziós numerikus (bármilyen beépített numerikus típusból) vagy logikai tömbök. A függvény argumentumai nem lehetnek egyszerre két vektorok: az egyik argumentumnak mátrixnak (kétdimenziós tömbnek) kell lennie. A matrix_b tömb első (vagy egyetlen) dimenziójában lévő elemek számának meg kell egyeznie a matrix_a tömb utolsó dimenziójában lévő elemek számával . Az F'90 szabvány bevezette.
Egyes esetekben, amikor egy oszlopvektor és egy sorvektor szorzatát számítjuk ki, amihez MATMULa vektorok további mátrixokká történő transzformálása szükséges, (/m,1/)és a függvény használatakor Barteniev [12](/1,n/) szerint a hatékonyság észrevehetően alacsonyabb, mint egy hagyományos beágyazott hurok. A NASA tesztjei [26] szerint a mátrixok (kétdimenziós tömbök) szorzatára vonatkozóan az Intel fordítójának teljesítménye a teljes optimalizálás -O3 esetén jelentősen (egyes esetekben egy nagyságrenddel) meghaladja a beágyazott hurkok teljesítményét. , bár a ~1000 × 1000 és nagyobb méretű mátrixok esetében ez némileg gyengébb, mint a LAPAK könyvtár DGEMM teljesítmény-alprogramjai . Ugyanakkor a ~100×100-as és kisebb mátrixok esetében a DGEMM-et felülmúlja a sebesség tekintetében. Az IBM Fortran fordítója az F'90-es verziótól kezdve a Winograd-Strassen algoritmust használja bonyolultan [27] ehhez . Ne feledje, hogy a matematikai függvények algoritmikus megvalósítását általában nem írja elő a szabvány, és a fordító fejlesztője dönti el. MATMUL
MATMULMATMULMATMUL

MERGE(t_source, f_source, mask) — olyan függvény, amely a maszk-tömb maszk vezérlése alatt új tömböt hoz létre a t_source és f_source tömbök eredeti tömbökével azonos alakú és méretű elemeiből. Az argumentumtömbök és az eredménytömb bármilyen beépített típusú lehet, és adattípusban, méretben és alakban megegyezhetnek.
Ha a maszk elem igaz ( .ТRUE.), akkor az eredménytömb megfelelő eleme egyenlő a t_source tömb megfelelő elemével ; ha false ( .FALSE.) — akkor az f_source tömb elemére .
A függvény argumentumai lehetnek skalárok; ebben az esetben például MERGE(a,0,c>=0)=a· Θ(с) , ahol Θ(с)  egy egész szám Heaviside függvény .

MOVE_ALLOC(from, to)egy beépített szubrutin, amely lehetővé teszi  a korábban lefoglalt dinamikus tömb dinamikus újrafoglalását új határokkal és mérettel, mint például a dinamikus tömb a -ból . A from tömbből származó adatok átmásolódnak a to tömbbe . A from és to tömbök adattípusának és rangjának meg kell egyeznie. A to tömb átcsoportosítása után a from tömb felszabadul, és kiosztatlanná válik. Hasznos lehet numerikus módszerekben a probléma változó diszkretizálásával ( multigrid és adaptív módszerek).
Az F2003 szabvány bevezette.

TRANSPOSE(matrix)egy kétdimenziós mátrixot transzponáló (sorokat és oszlopokat felcserélő)  függvény .

A modern Fortran beépített funkciókat biztosít a többdimenziós tömb egydimenziós tömbbe (illetve egydimenziós tömbből történő) egydimenziós tömbbe történő becsomagolásához és kicsomagolásához, logikai feltétel irányítása alatt a teljesítmény javítása és a memória megtakarítása érdekében.

PACK(array, mask [, vector]) - funkció; egy tetszőleges tömbtípusú többdimenziós tömböt csomagol a logikai tömbmaszk által vezérelt egydimenziós vektortömbbe . Az opcionális egydimenziós tömbvektornak ugyanabban az adattípusban kell lennie, mint a tömbnek , és a vektor elemeinek számának legalább annyinak kell lennie, mint a maszkban lévő valódi elemek száma . Ha a maszk  egy skalár értékkel , akkor a vektortömb elemeinek számának legalább akkorának kell lennie, mint a tömb elemeinek teljes száma . A függvény eredménye egy egydimenziós tömb lesz, amely ugyanolyan típusú, mint a tömb . Az eredmény hossza egyenlő lesz a vektor hosszával , ha egy adott; ha nem, akkor az igaz elemek száma a maszk tömbben . Ha a vektor nincs megadva, és a maszk  egy skalár, amelynek értéke true , akkor a kapott egydimenziós vektor hossza megegyezik a tömb elemeinek számával . Az eredményül kapott tömb sorban meg van töltve tömbelemekkel ( a számítógép memóriájában való elhelyezés sorrendjében), amelyek megfelelnek a maszk tömb valódi értékeinek . Ebben az esetben, ha egy vektor adott, akkor az eredménytömb hiányzó (esetleg) elemei abból kerülnek kijelölésre, és a tömb utolsó igaz elemét követő indexből kiindulva sorrendben . Tehát egy tömb esetén a függvény eredménye egy egydimenziós tömb lesz . Ha egy vektort is megadunk , akkor az eredmény . .TRUE.



PACK(A, mask=A.NE.0)PACK(A, mask=A.NE.0, V)

Fájlok és I/O

A Fortran gazdag beépített eszközökkel rendelkezik az input-output műveletekhez, beleértve a nagy adattömböket is. A Fortran fájlok belső és külső fájlok.

A belső fájl  bármilyen tömb, karakterlánc vagy részkarakterlánc. A belső fájlok alapértelmezés szerint mindig nyitva vannak. Külső fájl  minden olyan fájl, amely kívül esik a végrehajtott programon.

Mindkét fájltípus ugyanazt az írási WRITEés olvasási operátort használja READ. A belső fájlokat szám-karakterlánc-szám konverzióra, valamint vegyes numerikus és karakteres bejegyzések létrehozására használják.

Karakter ( 15 ) string Real :: xyz =- 12 3,456 Integer intg Írjon ( karakterlánc , * ) xyz ! Írjon -123.456 számot a karakterláncba Print * , 'string=' , string ! string=␣ -123.4560␣ ␣ Olvassa ( string , '(I6)' ) intg ! Egész szám beolvasása karakterláncból Print * , 'intg=' , intg ! intg=␣ -123 !...

A külső fájlok formázott (szöveges, CR- és LF-folyamok), bináris (bináris), közvetlenül megjelenítő RAM-ot és formázatlan (nem bináris) fájlok vannak felosztva. Ezenkívül lehetnek közvetlen és szekvenciális hozzáférésű fájlok rögzített és változó hosszúságú rekordokkal (változó csak szekvenciális fájlokhoz), valamint szegmentált rekordok (nagyon nagy formázatlan szekvenciális fájlokhoz). Így a Fortran meglehetősen nagy számú fájltípus létrehozását és feldolgozását teszi lehetővé - 15 rendezési mód. Egy rekord maximális mérete 2,14 bájt.

A közvetlen hozzáférésű fájlok lehetővé teszik, hogy adott számú rekordokon I/O műveleteket hajtson végre (anélkül, hogy felülírná a fájl magasabb vagy alacsonyabb bejegyzéseit).

Egy szekvenciális fájl megnyitásakor elhelyezhető az elejére, a végére (a "fájl vége" írása előtt), ami lehetővé teszi, hogy a korábban beírt felülírása nélkül felhalmozódjanak az adatok, valamint akár az elejére, akár a végére. végén, az előzőleg meghatározott fájlállapottól függően (megnyitva volt előtte vagy sem).

Munka a memóriával

A modern nyelvi szabványokban (a Fortran'90-től vagy a Fortran'95-től kezdve) háromféle dinamikus tömbökkel (automatikus, allokált és referenciatömbök), mutatókkal , hivatkozásokkal lehet dolgozni ; Vannak beépített eljárások a memóriával való közvetlen munkavégzéshez és eljárások a bitenkénti műveletekhez.

A nyelvi szabványok feltételezik a bármilyen típusú dinamikus tömb által elfoglalt RAM automatikus felszabadítását a program vagy szubrutin (eljárás, funkció) befejezése után, még akkor is, ha a kiadást a programozó nem hajtotta végre kifejezetten. Ez lehetővé teszi a memóriaszivárgások elkerülését , amikor dinamikus tömbökkel dolgozik Fortran használatával (mutatók használatakor és más esetekben szivárgás lehetséges), gondatlan programozással [12] .

Az automatikus tömbök (amelyeket a fordító helyez el) egy szubrutin meghívásakor jönnek létre, és azok helyi objektumai. Határukat minden alkalommal meghatározzák, amikor az eljárást elindítják; ugyanakkor, amikor kilép, megsemmisül, és a memória törlődik. Az automatikus tömbök a veremben vannak a program végrehajtása során , lefoglalva (az operátor segítségével ALLOCATE) - a halmon [25] .

A Fortran-mutatók hasonlóak a C-mutatókhoz [12] , azonban számítási feladatok megoldásakor és matematikai algoritmusok fejlesztésekor a legtöbb esetben sikeresen helyettesítik őket más Fortran-eszközökkel.

Vezérlési struktúrák

Az F'90 szabványtól kezdve a feltételes elágazás IF THEN - ELSEIF THEN - END IFnem különbözik más modern nyelvek hasonló konstrukcióitól, és felváltotta az ún. "aritmetika" IFcímkékkel, elavult [9] . A feltételes operátornak van egy egyszerűbb formája is: , ahol a végrehajtható operátornak kell az egyetlennek lennie az operátor után , például . IF(логическое условие) операторIFGoto метка

A választási konstrukció SELECT CASE - CASE - CASE DEFAULT - END SELECT, éppen ellenkezőleg, eltér a C-szerű nyelvek [28] , a Java nyelv [29] [30]SWITCH konstrukciójától,  és képességeit tekintve némileg hasonlít a Pascal [31] operátorára . .CASECASE

Egész N ( 74 ) ! Select kifejezés egész szám, logikai, karakteres kifejezés, vagy ... ! integer tömb vagy karaktertömb tetszőleges nullától eltérő számú elemmel nameSC : Select Case ( N ( i )) ! nameSC — konstrukció neve, N(i) — tömbelem Case (: - 5 ) ! +1 lépéssel minden N(i) esetén -5-nél kisebb vagy egyenlő ! 1. blokk Eset ( - 3 , - 1 , 0 , 2 ) ! a -3, -1, 0, 2 N(i) változóhoz ! 2. blokk Eset ( 50 : 100 ) ! N(i) esetén az 50 és 100 közötti tartományban (+1. lépés) ! 3. blokk Case ( 400 ) ! ha N(i)=400 ! 4. blokk Eset ( 1 , 20 : 30 , 35 ) ! ha N(i)=1, N(i) a 20 és 30 közötti tartományban, és N(i)=35 ! 5. blokk Alapértelmezett eset ! minden más helyzetre. Case Default – nem kötelező, nem kötelező utasítás ! Alapértelmezett blokk Vége Válassza ki a nevet SC

Ha a kiválasztási kifejezésnek nevezett N változó értéke megegyezik a kiválasztók listájával (értéklista vagy tartomány) bármely utasításban CASE, például a harmadikban N=70 esetén, akkor a megfelelő blokk végrehajtása után A blokk-3 utasítások közül a konstrukciós kilépések SELECT CASE[12] [25] és a megszakítási utasítások (például BREAK) nem szükségesek . Az operátor CASE DEFAULT, valamint a konstrukció neve nem szükséges. A különböző operátorok választólistáiban a tartományok CASEnem fedhetik át egymást, és nem lehetnek legalább egy közös elemük.

A választási kifejezés (N) egy egész tömb eleme lehet.

A választólisták tartományai csak egész számokra vagy karakterekre vonatkoznak, alulról felfelé növekvő sorrendben; karaktereknél - kódjaik növekvő sorrendjében .

A modern Fortranban az iterációs számlálóval rendelkező hurkok két formája létezik: a hagyományos felépítés és DOa ENDDOfeliratozott hurok. Ez utóbbit az F'90-es szabvány óta elavult konstrukciónak ismerik el, de továbbra is szerepel a szabványokban. Több beágyazású beágyazott hurkok esetén az utolsó űrlap tömörebb lehet:

! Az elavult hurokkonstrukció szintaxisa csináld 1 k = 1 , 10 ! 1 a hurok vége 1 j = 1 , 20 ! _ címke lehet ugyanaz a beágyazott hurkok esetén do 1 i = 1 , 100 arr ( i , j , k ) = 25 1 Folytatás ! a címke csak bármely kezelő előtt jelenhet meg L1 : do k = 1 , 10 ! a modern jelölések azonban lehetővé teszik a ciklusok elnevezését, L2 : j = 1 , 20 ! _ ami jobban megfelel a strukturált programozás koncepciójának L3 : do i = 1 , 100 ! és megkönnyíti a hibák elkerülését arr ( i , j , k ) = 25 vége az L3-nak vége az L2-nek vége az L1-nek

A számlálóval ellátott hurokfejléc teljes alakja a következő:

név : DO I = N1 , N2 , dN ! A konstrukció neve nem kötelező ... ! N1 a számláló kezdőértéke, N2 a végső érték, dN a lépés (hurok paraméterei) END DO név ! A ciklusparaméterek tetszőleges előjelű egész számok. dN nem nulla.

A huroktest megszakítás nélküli végrehajtásának száma N c = max( int((N 2 -N 1 +dN)/dN), 0 ) és egyenlő lehet nullával.

Például a ciklus nulla alkalommal fog végrehajtani, ha N 2 <N 1 és a lépés pozitív: dN>0 . Ha a lépés negatív, dN<0, akkor a ciklus fordított sorrendben megy végbe, míg a ciklus befejezéséhez az szükséges, hogy N 2 <N 1 . Ha a dN lépést kihagyjuk, akkor alapértelmezés szerint eggyel egyenlőnek tekintjük: dN=1 .

Az I hurokváltozó értéke a kilépés után mindig egyenlő N s +1 , azaz eggyel több, mint a ciklus iterációinak száma és nem kevesebb, mint eggyel: I≥1.

Lehetséges egy feltételes ciklus  - , és egy végtelen ciklus  - is, amelyek szabványos formával rendelkeznek. DO WHILE(логическое условие)END DODOEND DO

Az operátor CYCLE имя циклаmegszakítja a ciklus aktuális iterációját, és továbblép ugyanazon ciklus következő iterációjára. Ha a hurok neve nincs megadva, akkor az aktuális hurok (amelyben az operátor található CYCLE) iterációja megszakad.

Az operátor EXIT имя циклаmegszakítja a megadott nevű ciklus végrehajtását és továbbadja a vezérlést, ha pedig nincs név, megszakítja az aktuális ciklust (amelybe az operátor be van ágyazva EXIT).

CYCLEA és operátorok EXITlogikailag azonosak egy operátorral GOTO(megfelelő körülmények között), de sokkal könnyebbé teszik a kód megértését és karbantartását a programozó számára.

Fordítók

A nyelv kezdeti fejlesztése óta a Fortran fordítókat az IBM gyártja. Jelenleg az IBM szállítja a VS Fortran optimalizáló fordítót [32] IBM System z nagyszámítógépekhez , melynek különböző verzióinak fejlesztési története 1964-ig nyúlik vissza, valamint az XL Fortran fordítót [33] a PowerPC architektúrán alapuló platformokhoz  . AIX , Linux és szuperszámítógép Blue Gene (volt Mac OS X -re is verzió , amikor a Macintosh számítógépek PowerPC processzorokat használtak). Mindkét fordító nagyon kifinomult optimalizálót tartalmaz, az IBM szakemberei fél évszázados folyamatos tudományos munkájának eredményeként. Az IBM Fortran XL fordítója alapján az Absoft, az IBM üzleti partnere megalkotta és szállítja az Absoft Pro Fortran fordítót PowerPC (Linux, Mac OS X) és Intel (Linux, Mac OS X, Windows) processzorokon alapuló rendszerekhez. [34] .

1997 - ig a Microsoft Corporation a Windows operációs rendszerhez készült Fortran fordító egyik fő gyártója volt . Ezt követően az alacsony jövedelmezőség miatt felhagyott fejlesztésükkel. Ezt követően a fordítóprogramot a DEC szállította, amely 1998-ban a Compaq része lett , és utóbbival együtt 2002-ben egyesült a HP -val . A fordító ezen verzióját az Intel fejlesztette tovább , és a fordító neve Intel Fortran Compiler , amely lehetővé teszi az Intel IA-32, x86_64 és IA-64 platformok kódjának optimalizálását.

A DEC a Digital Visual Fortran fejlesztői környezetbe integrált fordítót biztosít, amely a Microsoft Visual Studio alapú . A sorozat leghíresebb termékei az FPS 4.0 (Microsoft Fortran Power Station), a DVF 5.0 és a 6.0. Minden fordító több Fortran szabványt is támogathat. Az összefonódások következtében későbbi termékek jelentek meg a piacon Compaq és HP márkanév alatt. A HP jelenleg egy 6.6-os fejlesztői környezetet árul Intel/win32-hez. A Fortran támogatás minden HP nagy teljesítményű platformon is megvalósul.

A Fortran fejlesztőrendszerek másik jelentős beszállítója a Lahey , amely integrált megoldásokat kínál Windowsra és Linuxra.

Sokáig a Watcom fordítót tartották a legjobb PC-s Fortran fordítónak , amit külön Open Watcom projektre különítettek el , amely nyílt alapon fejleszti a fordítót.

Az ingyenes Fortran fordítók közül kiemelendő az egykori Sun Microsystems (ma Oracle) fordítója, amely a Sun Studio része , amely hatékony kódot generál SPARC , x86 és x86-64 alatt [35] és elérhető Solaris , OpenSolaris számára. és GNU/Linux .

A GNU Free Software Foundation kiadta a g77 Fortran 77 fordítót, amely nyílt forráskódú és szinte minden platformon elérhető, és teljes mértékben kompatibilis a GCC -vel . Most a GFortran fordító váltotta fel , amely megvalósítja a Fortran-95 szabvány szinte összes konstrukcióját, valamint a Fortran-2003, Fortran-2008 és Fortran-2018 szabványok konstrukcióinak nagy részét. Visszafelé is teljesen kompatibilis a Fortran-77-tel. Létezik egy független g95 projekt is a GCC alapú Fortran-95 fordító létrehozására .

Interakció más nyelvekkel

Számos programozási rendszer lehetővé teszi a Fortran program fordítása eredményeként kapott objektumfájlok összekapcsolását más nyelvű fordítóktól származó objektumfájlokkal, ami lehetővé teszi rugalmasabb és többfunkciós alkalmazások létrehozását. A Fortran nyelvhez is nagyszámú könyvtár érhető el, amelyek egyaránt tartalmazzák a klasszikus számítási feladatok megoldására szolgáló rutinokat ( LAPACK , IMSL , BLAS ), az elosztott számítástechnikai rendszerezési feladatokat ( MPI , PVM ), valamint a grafikus interfészek felépítésére szolgáló feladatokat ( Quickwin , FORTRAN ). / TK ) vagy hozzáférés a DBMS -hez ( Oracle ).

Fortran a Szovjetunióban

A Fortran a Szovjetunióban később jelent meg, mint Nyugaton, mivel eleinte a Szovjetunióban az Algolt ígéretesebb nyelvnek tartották . A Fortran bevezetésében fontos szerepet játszott a szovjet fizikusok kommunikációja a CERN munkatársaival , ahol az 1960-as években szinte minden számítást Fortran programokkal végeztek [36] .

Az első szovjet Fortran fordítót 1967-ben hozták létre a Minsk-2 géphez , de nem kapott nagy hírnevet. A Fortran széleskörű bevezetése a BESM-6 géphez készült FORTRAN-DUBNA fordító 1968-as létrehozása után kezdődött . A Fortran az ASVT és SM számítógépek fő nyelve, amelyet gyakran a RATFOR előfeldolgozóval együtt használnak . Az 1972 -ben megjelent ES számítógépeken már kezdetben volt Fortran fordító (az IBM/360 -tól "kölcsönzött" más szoftverekkel együtt).

Az 1970-es években az IPM kifejlesztette a GRAFOR grafikus könyvtárat („Graphic Extension of FORtran”) [37] .

Az 1980-as évek végén és az 1990-es évek elején Andrej Zareckij fizikus gyermekkönyv-sorozatot hozott létre, amelynek egyik főszereplője Fortran professzor volt, aki a számítógépes műveltség és a programozás alapjait magyarázta el a gyerekeknek hozzáférhető nyelven [38] [39]. .

Jegyzetek

  1. ↑ 1 2 3 4 A FORTRAN I., II. és III. története – Az ACM folyóirata , 1981.
  2. ↑ V.E. Karpov. AZ ÖSSZEÁLLÍTÓK KLASSZIKUS ELMÉLETE. - Oktatóanyag. 2. kiadás - Moszkva, 2011. - 91 p. - ISBN 5-230-16344-5.
  3. ↑ A pálmának mondó Plankalkül nyelvet még 1945-ben találták fel, de csak 2000-ben vezették be.
  4. ↑ Idegen szavak szótára. - M .: " Orosz nyelv ", 1989. - 624 p. ISBN 5-200-00408-8
  5. ↑ Lásd például: Netlib Repository az UTK-nál és az ORNL -nél archiválva 2021. július 27-én a Wayback Machine -nél
  6. ↑ IMSL Fortran Numerical Library | Gazember hullám . Letöltve: 2015. augusztus 19. Az eredetiből archiválva : 2015. augusztus 16..
  7. ↑ Bartenyev O.V. 1-3 // Fortran szakembereknek. ISML matematikai könyvtár. - Moszkva: Dialog-MEPhI, 2001. - p1 - 448 p., p2 - 320 p., p3 - 368 p. - 3000 példányban.  - ISBN 5-86404-157-2 (2. rész), 5-86404-18-58-0 (3. rész).
  8. ↑ 1 2 3 4 5 6 7 8 9 A. M. Gorelik . A Fortran programozási nyelv evolúciója (1957-2007) és fejlesztésének kilátásai // Számítási módszerek és programozás, 2008, 9. köt. 53-71 Archiválva : 2015. április 2. a Wayback Machine -nál
  9. ↑ 1 2 3 Gorelik A.M. 2. rész, 14-20. fejezet // Programozás a modern Fortranban. - Moszkva: Pénzügy és statisztika, 2006. - 352 p. - 3000 példányban.  — ISBN 5-279-03066-X .
  10. ↑ ANSI. X3.9-1966 - FORTRAN . — 1966. Archiválva : 2020. november 1. a Wayback Machine -nál
  11. ↑ Fortran 77 - ANSI X3J3/90.4 munkacsoport  . Letöltve: 2021. február 18. Az eredetiből archiválva : 2020. november 11.
  12. ↑ 1 2 3 4 5 6 7 8 Bartenyejev O.V. Modern Fortran . - M . : Dialógus MEPhI, 2005. - ISBN 5-86404-113-0 . Archiválva : 2011. február 10. a Wayback Machine -nél
  13. ↑ Fortran 90 – Utolsó munkavázlat  . wg5-fortran.org . Letöltve: 2021. február 18. Az eredetiből archiválva : 2020. november 5..
  14. ↑ A. M. Gorelik. Objektumorientált programozás a Modern Fortranban archiválva 2011. szeptember 7. a Wayback Machine -nél
  15. ↑ Fortran 95 – Utolsó munkavázlat  . wg5-fortran.org . Letöltve: 2021. február 18. Az eredetiből archiválva : 2021. július 1.
  16. ↑ Gorelik A.M. 3. Bevezetés a párhuzamos programozásba Fortranban // Programozás a modern Fortranban. - Moszkva: Pénzügy és statisztika, 2006. - 352 p. — ISBN 5-279-03066-X .
  17. ↑ 1 2 S. D. Algazin, V. V. Kondratiev. Programozás Visual Fortranban. - M . : " MEPhI párbeszéd ", 2008. - 448 p. — ISBN 5-8243-0759-8 .
  18. ↑ Fortran 2003 – Utolsó munkatervezet . Gnu.Org. Letöltve: 2014. május 10. Az eredetiből archiválva : 2021. február 25.
  19. ↑ Fortran 2008 – Utolsó munkatervezet . Gnu.Org. Letöltve: 2014. május 10. Az eredetiből archiválva : 2021. március 3.
  20. ↑ Gorelik A. M. News 2012. március 2-i archív példány a Wayback Machine -n
  21. ↑ Fortran 2018 . ISO. Letöltve: 2018. november 30. Az eredetiből archiválva : 2017. december 1..
  22. ↑ További interoperabilitás a C -vel. ISO. Letöltve: 2017. november 20. Az eredetiből archiválva : 2021. március 8.
  23. ↑ További párhuzamos szolgáltatások a Fortranban . ISO. Letöltve: 2017. november 20.
  24. ↑ Troy Douglas, Douglas A. Troy. per. angolról. B. A. Kuzmina. Programozás C nyelven az IBM PC-hez = Teljes C nyelvű programozás az IBM-PC / IV Emelin számára. - Moszkva: "Rádió és kommunikáció", 1991. - 432 p. - ISBN 5-256-00707-6 , 0-316-85311-9.
  25. ↑ 1 2 3 Gorelik A.M. 1. rész, 1-13. fejezet // Programozás a modern Fortranban. - 1. - Moszkva: Pénzügy és statisztika, 2006. - 352 p. — ISBN 5-279-03066-X .
  26. ↑ Thomas Clune. A Python, NumPy, Matlab, Fortran stb. . NASA modellező guru (2009. november 2. 10:33). Letöltve: 2015. október 7. Az eredetiből archiválva : 2015. október 23..
  27. ↑ Craig C. Douglas, Gordon Slishman. Mátrix-mátrix szorzás változatai Fortran-90-hez  // SIGNUM Newsl .. - 1994-04-01. - T. 29 , sz. 2 . — P. 4–6 . — ISSN 0163-5778 . - doi : 10.1145/181498.181500 . Archiválva az eredetiből 2021. augusztus 9-én.
  28. ↑ Switch utasítás (C++) . msdn.microsoft.com. Hozzáférés dátuma: 2016. június 5. Az eredetiből archiválva : 2016. augusztus 13.
  29. ↑ A kapcsoló felépítése . learning.javascript.ru. Letöltve: 2016. június 5. Az eredetiből archiválva : 2016. június 9..
  30. ↑ A switch utasítás finomságai . habrahabr.ru. Letöltve: 2016. június 5. Az eredetiből archiválva : 2016. június 17.
  31. ↑ Az esetleírás . www.freepascal.org. Letöltve: 2016. június 5. Az eredetiből archiválva : 2016. május 22.
  32. ↑ VS FORTRAN . Letöltve: 2010. március 8. Az eredetiből archiválva : 2021. augusztus 9..
  33. ↑ XL Fortran Linuxhoz . Letöltve: 2010. március 8. Az eredetiből archiválva : 2021. augusztus 9..
  34. ↑ Az Absoft Pro Fortran Compiler Suites általános áttekintése . Letöltve: 2010. március 8. Az eredetiből archiválva : 2021. augusztus 9..
  35. ↑ Sun Studio - Benchmarks . Letöltve: 2007. november 20. Az eredetiből archiválva : 2007. október 26..
  36. ↑ Alexander Rastorguev esszéje Fortran dubnai megjelenéséről . Hozzáférés dátuma: 2012. január 22. Az eredetiből archiválva : 2014. július 10.
  37. ↑ A számítógépes grafika története Oroszországban (elérhetetlen link) . Hozzáférés dátuma: 2012. január 8. Az eredetiből archiválva : 2012. március 17. 
  38. ↑ Fortran professzor enciklopédiája , Sutki.net  (2008. január 29.). Az eredetiből archiválva: 2012. március 10. Letöltve: 2013. június 11.
  39. ↑ Kirilenko, Alexander . Észtország a programozást az általános iskolai osztályoktól kezdve vezeti be az iskolákban , a Noosphere -t  (2009. szeptember 7.). Az eredetiből archiválva : 2012. szeptember 9. Letöltve: 2013. június 11.

Irodalom

Linkek

  Ugrás a Wikidata elemre  A közösségi hálózatokon
Tematikus oldalak
Szótárak és enciklopédiák
 Programozási nyelvek