Fortran

Fortran
Semantik imperativ , parallell
Språkklass processuell , modulär , med inslag av objektorienterad programmering
Utförandetyp sammanställt
Framträdde i 1957
Författare John Backus , IBM
Utvecklaren IBM [1] och John Backus [1]
Filtillägg _ .for .f .f90 .f95
Släpp Fortran 2018 (ISO/IEC 1539-1:2018) (28 november 2018)
Typ system strikt , statisk
Stora implementeringar GFortran , Open Watcom , Sun Studio , XL Fortran , Intel Fortran
Dialekter Högpresterande Fortran
Blivit påverkad Hastighetskodning [d]
påverkas ALGOL 68 , BASIC , PL/I
Hemsida fortran-lang.org _ 
 Mediafiler på Wikimedia Commons

Fortran ( eng.  Fortran ) är det första programmeringsspråket på hög nivå som har fått praktisk tillämpning, har en översättare och har upplevt vidareutveckling [2] . Skapad mellan 1954 och 1957 av en grupp programmerare ledda av John Backus på IBM Corporation [3] . Namnet Fortran är en förkortning av FOR mula TRAN slator (formelöversättare) [4] . Fortran används i stor utsträckning främst för vetenskapliga och tekniska beräkningar. En av fördelarna med moderna Fortran är ett stort antal program och bibliotek av subrutiner skrivna på den [5] .

Det finns ett stort antal olika matematiska bibliotek skrivna i Fortran (mest i äldre versioner av språket) för matrisalgebra och lösningssystem av linjära ekvationer , bibliotek för att lösa differentialekvationer , integralekvationer och deras system, approximation av funktioner , specialfunktioner , snabba Fourier-transformationer , matematisk statistik och andra matematiska discipliner. Dessa bibliotek levereras vanligtvis med kompilatorn. Ett antal sådana paket har skapats under årtionden och är fortfarande populära i forskarsamhället till denna dag, till exempel International Mathematical Subroutine Library (IMSL) [6] [7] .

De flesta av dessa bibliotek är i själva verket mänsklighetens egendom: de är tillgängliga i källkod, väldokumenterade, felsökta och mycket effektiva.

Modern Fortran (Fortran 95 och Fortran 2003) har skaffat de funktioner som krävs för effektiv programmering för nya datorarkitekturer; låter dig tillämpa modern programmeringsteknik, i synnerhet generisk och modulär programmering , OOP , samtidigt som kontinuiteten med tidigare versioner bibehålls. Ett av huvudkoncepten för utvecklingen av moderna Fortran är parallellismstöd och vektoroperationer [8] .

Utvecklingen av språkstandarder

Fortran är ett mycket standardiserat språk, så det kan enkelt porteras till olika plattformar. De nya språkstandarderna behåller till stor del kontinuitet med de äldre, vilket gör det möjligt att använda koder för tidigare skrivna program och modifiera dem [8] . Samtidigt som språket utvecklas aviseras i förväg föråldrade konstruktioner som kan komma att tas bort i framtiden [9] .

FORTRAN 66 (1966)

ANSI X3.9-1966 -standarden [10] definierade FORTRAN-språket (baserat på IBMs FORTRAN IV, som fungerade som de facto-standarden). Det hänvisades senare till som FORTRAN 66, även om många fortsatte att referera till det som FORTRAN IV, det språk som standarden till stor del baserades på.

FORTRAN 77 (1978)

ANSI X3.9-1978, ISO 1539:1980 [11] , många förbättringar [8] :
  1. Operatörer för att öppna och stänga en fil ( OPEN, CLOSE) och utdata till en standardenhet - PRINT.
  2. Lade till strängdatatyp och funktioner för dess bearbetning.
  3. Blockoperatören och IF konstruktion IF THEN - ELSE IF THEN - introduceras END IF, liksom programfragmentinkluderingsoperatorn INCLUDE.
  4. Introducerade möjligheten att arbeta med direktåtkomstfiler.
  5. Den maximala dimensionen för en array har ökats från 3 till 7. Restriktioner för arrayindex har tagits bort.
  6. Möjligheterna att arbeta med rutiner har förbättrats och utökats.
  7. Konceptet med en intern fil (som är arrayer, numeriska och strängvariabler) har introducerats. Interna filer gör det i synnerhet möjligt att utföra konverteringar av siffersträngar och strängar med vanliga läs- och skrivoperatorer READoch WRITE[12] .

Fortran 90 (1991)

ISO/IEC 1539:1991 (ANSI INCITS 198-1992) [13] reviderade avsevärt språkstandarden [12] inklusive byte av namnet på FORTRAN till Fortran.
  1. Introducerade ett gratis format för att skriva kod. Ytterligare beskrivningar dök upp IMPLICIT NONE, TYPE, ALLOCATABLE, POINTER, TARGET, NAMELIST.
  2. Kontrolloperatörer och konstruktioner introduceras. Lade till DO… END DO(istället för att avsluta slingan med en etikett), DO WHILE, styröverföringsoperatör till början av slingan CYCLE, urvalskonstruktion SELECT CASE(för att ersätta besvärliga konstruktioner IFoch operatörer GOTO), samt den sista operatören för en programenhet, modul eller intern procedur END[8] .
  3. Introducerade pekverktyg och funktioner för att arbeta med RAM (i analogi med C-språket).
  4. Operatörer för att arbeta med dynamiskt minne ( ALLOCATE, DEALLOCATE, NULLIFY) har introducerats.
  5. Tillagda mjukvarukomponenter MODULE, PRIVATE, PUBLIC, CONTAINS, INTERFACE, USE, INTENT.
  6. Maskering av array-tilldelning har införts (tilldelning när ett logiskt villkor som ställs på array-element är uppfyllt utan att använda villkorliga operatorer), samt arbete med array-sektioner. En operatör och en konstruktion WHEREför partiell byte av cykler införs (höger sida av uppdragsoperatören ändras inte). Tilldelningsmaskering gäller nästan alla operatorer, konstruktioner och funktioner som fungerar på arrayer.
  7. Standardoperationerna för tilldelning, addition, subtraktion och division och multiplikation med ett tal utökas till arrayer och deras sektioner definierade av sektioner. I detta fall utförs element-för-element-tilldelning.
  8. Det finns nya inbyggda funktioner, främst för att arbeta med arrayer. Funktioner för beräkningar i matriser: ALL(logisk produkt) och MASK(logisk addition), COUNT(antal sanna element), PRODUCT(produkt av matriselement), SUM(addition av matriselement), DOT_PRODUCT(skalär produkt), MATMUL(matrismultiplikation). Hjälpfunktioner har lagts till, liksom funktionerna för att omforma och vika arrayer.
  9. OOP- element dök upp i språket [14] . Introducerade härledda datatyper. En lista över föråldrade språkfunktioner som ska tas bort i framtiden har tillkännages separat.
  10. Ytterligare funktioner för att arbeta med strängdata har lagts till, i synnerhet funktionerna TRIM(ta bort mellanslag) och REPEAT(flera kopior av en sträng) och vänster- och högerjusteringsfunktionerna.

Fortran 95 (1997)

ISO/IEC 1539-1:1997 [15] , en revidering av den tidigare standarden. Operatören och konstruktionen introduceras FORALL, vilket ger mer flexibilitet än operatören och konstruktionen WHERE, för att tilldela arrayer och ersätta besvärliga loopar. FORALLlåter dig ersätta alla tilldelningar av sektioner eller operatör och konstruktion WHERE, i synnerhet ger tillgång till diagonalen av matrisen. Denna operatör anses lovande inom parallell beräkning, vilket bidrar till mer effektiv parallellisering än loopar [16] [12] [17] .

Fortran 2003 (2004)

Antagen som ISO/IEC 1539-1:2004 [18] . Vidareutveckling av OOP- stöd i språket. Interaktion med operativsystemet. Följande funktioner har också lagts till [8] :
  1. Asynkron data input-output.
  2. Medel för interaktion med C- språket .
  3. Förbättring av dynamisk dataplacering [17] .

Fortran 2008 (2010)

ISO/IEC 1539-1:2010, det vanliga informella namnet på Fortran 2008 [19] . Standarden förutsätter stöd med hjälp av det parallella beräkningsspråket (Co-Arrays Fortran) [8] [20] . Det är också planerat att öka den maximala dimensionen av arrayer till 15, lägga till inbyggda speciella matematiska funktioner [8] osv.

Fortran 2018

Den senaste versionen av Fortran 2018-språket (tidigare känt som Fortran 2015) släpptes den 28 november 2018 [21] . Fortran 2018 (ISO/IEC 1539-1:2018) inkluderar: Samt stöd för ISO/IEC/IEEE 60559:2011 , hexadecimal flyttal in/utdata, IMPLICIT NONE-förbättringar och andra ändringar.

Funktioner och egenskaper hos språket

Fortran har en stor uppsättning inbyggda matematiska funktioner, stöder arbete med heltal, reella och komplexa tal med dubbel och hög precision (den används för binära operationer real(10)), har en rik verktygslåda för att arbeta med arrayer och externa filer. Modern Fortran (2003 och senare) har en komplett verktygslåda för att arbeta med karaktärsdata.

Inledningsvis var språkets uttrycksfulla medel inte särskilt stora, eftersom Fortran var det första språket på hög nivå som implementerades. Senare lades många lexikaliska konstruktioner till Fortran, som är karakteristiska för strukturell, modulär, generaliserad och objektorienterad programmering.

Kodnotationsformat

Strukturen i programmen var ursprungligen inriktad på input från hålkort och hade ett antal egenskaper som var lämpliga för just detta fall. Så från den 1:a till den 5:e kolumnen fanns det ett etikettområde, den 6:e tjänade till att markera texten som en fortsättning på föregående rad (vilket tecken som helst förutom ett mellanslag och "0"), och från den 7:e till den 72:e faktiska texten var lokaliserad operatör eller kommentar. Kolumnerna 73 till 80 kunde användas för kortnumrering (för att återställa en oavsiktligt spridd kortlek) eller för en kort kommentar, de ignorerades av översättaren. Om operatörens text inte passade in i det tilldelade utrymmet (från 7:e till 72:a kolumnen), placerades ett fortsättningstecken i den 6:e kolumnen på nästa rad, och sedan fortsatte operatören på den. Det var omöjligt att placera två eller flera operatörer på en rad (karta). När hålkort blev historia förvandlades dessa fördelar till allvarliga olägenheter.

Det är därför Fortran-standarden, som börjar med Fortran 90, samtidigt som källtextens fasta format bibehålls, lades till fritt format , som inte reglerar radens position och låter dig skriva mer än ett påstående per rad. Införandet av fritt format och moderna metoder för strukturerad programmering [8] har gjort det möjligt att skapa kod vars läsbarhet och tydlighet inte är sämre än kod skapad med andra moderna programmeringsspråk som Pascal , C eller Java . Moderna utvecklingsmiljöer låter dig kombinera format: utöka till exempel längden på en sträng till ett fritt format (vanligtvis 132 tecken), låter dig skriva flera påståenden per rad, men låter dig samtidigt behålla vänster indrag (gör en vänstermarginal), karakteristisk för det gamla fasta formatet, lämna den mest dedikerade kolumnen för felmärken och format, samt en radfortsättningskolumn.

Ett slags "telefonkort" av det gamla Fortran är ett stort antal etiketter som användes i ovillkorliga GOTOhoppoperatorer, loopoperatorer, villkorsoperatorer och formatinput-outputbeskrivningsoperatorer FORMAT. Det stora antalet etiketter och uttalanden GOTOgjorde ofta Fortran-program svåra att förstå.

Det är denna negativa upplevelse som har blivit anledningen till att etiketter och deras tillhörande ovillkorliga hoppoperatorer har modifierats kraftigt i ett antal moderna programmeringsspråk (till exempel i Java-språket ).

Men moderna Fortran (främst med början från Fortran'90-versionen) är befriat från ett överskott av etiketter på grund av introduktionen av operatorer som DO… END DO, DO WHILE, SELECT CASE, konstruktioner IF THEN- ELSEIF THEN- ELSE- END IF, etc. Dessutom, i moderna språkstandarder, endast de klassiska operatör som GOTOanvänds på många språk till denna dag. Den beräknade operatorn GOTO, såväl som ENTRY konstruktionen med flera ingångar till procedurer, togs bort från standarden, även om de i allmänhet fortfarande stöds av kompilatorer.

Hej världen!

Fast format (mellanslag på radpositionerna 1 till 6 är markerade med "␣"-tecken):

␣␣␣␣␣␣ SKRIV UT * , ' Hej världen!' ␣␣␣␣␣␣ SLUT

Fritt format:

print * , "Hej världen!" slutet Anmärkningar.
  • Huvudprogramstartsatsen PROGRAMär valfri. Strängt taget är det enda obligatoriska uttalandet i ett Fortran-program END.
  • Valet av stora eller små bokstäver för att skriva programförklaringar är godtyckligt. När det gäller moderna Fortran-språkstandarder är många stora bokstäver och många små bokstäver desamma.

Datatyper

Fortran stöder 5 grundläggande elementära inbyggda datatyper: verkligt ( REAL) , komplext ( COMPLEX) , heltal ( INTEGER) med eller utan tecken, booleskt ( LOGICAL) och tecken ( CHARACTER) . Det är också möjligt att skapa härledda datatyper med hjälp av TYPE. Från början av skapandet av språket fanns det 4 datatyper: verklig, komplex, heltal och boolesk.

Det finns en föreställning om en sorts datatyp eller typparametrar. Detta gör att du kan parametrisera verkliga och komplexa data (det vill säga specificera precisionen och omfånget för decimalordningen) och andra data, vilket ökar applikationernas portabilitet.

För alla numeriska data är de vanliga aritmetiska operationerna och tilldelningarna definierade, och det finns inbyggda funktioner. En inbyggd funktion kan bara ta ett reellt eller komplext tal ( inte ett heltal ) som argument .Log(x)x

Som regel, för "enkla" precisionsreella tal, tilldelas 4 byte ( REAL(4), eller typvariationsparameter KIND=4), "dubbel" - 8 byte. För komplexa tal fördubblas antalet byte.

Heltal kan ta från 1 till 4 byte. Moderna kompilatorer tillåter programmeraren att arbeta med siffror och "fyrdubblad" precision.

I aritmetiska operationer ändras typen som standard från ett heltal till ett reellt och sedan ett komplext tal, eller genom att använda en speciell inbyggd numerisk funktion. Så, följande uttryck är ekvivalenta ( i  är ett heltal): och . Log(i*1.)Log(real(i))

Strängdata (tecken) anges med en längd inom parentes, antingen efter typattributet eller efter strängnamnet. För att ange en sträng i programkroppen används enkla eller dubbla citattecken. Så, posterna är likvärdiga: A='Det är varmt' eller A="Det är varmt" . Detta är användbart i fall där det finns citattecken i själva strängen: B="Det är inte varmt" .

För strängar finns det en inbyggd strängsammansättningsoperation (addition): //. Det finns 17 specialiserade inbyggda funktioner för teckendata (utöver de generiska som hanterar alla typer av data).

Etiketter  är heltal med högst 5 siffror; tecken är inte tillåtna. Etiketter används i satser GO TO, läs, skriv och formaterar satser, samt fel- och undantagshantering. Förutom etiketter har Fortran möjligheten att namnge kontrollstrukturer (slingor, logiska villkor, strukturer FORALL... END FORALL, WHERE... END WHERE, SELECT CASE... END SELECT, TYPE... END TYPE, etc.), och namnet på strukturen kan innehålla alla tecken tillåtet i variabelnamn.

Inbyggda funktioner för teckendata

För tal- teckenkonvertering : CHAR(i)och ACHAR(i). Konvertera ett heltal till dess motsvarande operativsystemtecken eller ASCII -tabelltecken .

För tecken- nummerkonvertering : ICHAR(i)och IACHAR(i). Utför omvända transformationer.

Strängjämförelsefunktioner : LGE(A,B), LGT(A,B), LLE(A,B)och LLT(A,B). Resultatet av funktionerna är "sant" om stränglängderna ( L(A) och L(B) ), uttryckta i ASCII-tecken, uppfyller följande olikheter, respektive: L(A) L(B), L(A) L(B), L(A) L(B) och L(A) L(B) .

Längdfunktioner : LEN(A)och LEN_TRIM(A). Den första returnerar längden på strängen A (antal tecken), den andra returnerar längden på strängen utan efterföljande mellanslag, om några.

Konverteringsfunktioner : TRIM(A), ADJUSTL(A)och ADJUSTR(A), REPEAT(A,N). Funktionen TRIM(A)returnerar strängen A utan efterföljande mellanslag. Funktionerna ADJUSTL(A)och ADJUSTR(A)justerar en sträng (ta bort mellanslag) till vänster respektive höger. Funktionen REPEAT(A,N)returnerar N kopior av sträng A.

Radsökningsfunktioner: , , . Den valfria parametern tillbaka anger sökriktningen: som standard vänster (för ) höger (för ). SCAN(A,B,[back])INDEX(A,B,[back])VERIFY(A,B,[back])back=.false.back=.true.

Funktionen SCANbestämmer positionsnumret i sträng A (vänster eller höger) för det första hittade tecknet från stränglistan B . Om resultatet är negativt kommer funktionen att returnera ett heltal 0. Funktionen INDEXbestämmer numret på den position från vilken hela förekomsten av sträng B i sträng A börjar för första gången . Dessutom kan sökningen utföras både till vänster och till höger, men positionsnumret beräknas alltid till vänster, från början av raden. Om sökningen misslyckas kommer funktionen att returnera 0. Funktionen är VERIFY omvänd till funktionen INDEX. Således VERIFYreturnerar den positionsnumret för ett sådant tecken i strängen A , som inte finns i masksträngen B . Om alla (olika) tecken i sträng A finns i masksträng B, kommer funktionen att returnera 0.

Alla dessa funktioner är elementära och deras argument kan vara en rad tecken eller heltal. Resultatet blir en matchad numerisk, tecken- eller logisk array.

Fortran-standarder, från och med version 2003, ger möjlighet att arbeta med Unicode-tecken .

Utöver dessa funktioner låter Fortran dig bearbeta symbolisk data med hjälp av dess inbyggda matrisanalys (vektor) , vilket avsevärt ökar flexibiliteten för bearbetning av symbolisk data.

I Fortran, för kompatibilitet med program skrivna på C-språket, finns konceptet med en C-sträng , som specificeras genom att lägga till ett tecken efter citatet: A='This is a C-string'c . Nollsträngen kommer att ges så här: A='\0'c .

Subrutiner (procedurer och funktioner)

Subrutiner i Fortran har funnits sedan den allra första standarden och är fortfarande ett av de viktigaste programmeringsverktygen [8] .

I Fortran sker anrop av subrutiner, funktioner och överföring av deras parametrar uteslutande genom referens (och inte genom värde ). Därför kan subrutinen ändra argumentet som skickas till den i huvudprogrammet, om detta inte specifikt förhindras. En sådan mekanism gör det möjligt att göra notationen naturlig när man skriver matematiska formler och samtidigt upprätthålla hög prestanda när man arbetar med stora datamatriser [24] .

Fortran-subrutiner kan innehålla i listan över parametrar (kallade formella parametrar) och valfria (valfria) parametrar, eller så kan de inte innehålla några parametrar alls.

Språkstandarden tillåter att procedurer och operationer överbelastas via ett generiskt gränssnitt, som kombinerar olika procedurer (var och en arbetar på till exempel heltal, reella, komplexa tal och teckenvariabler) under ett enda (generiskt) namn. I det här fallet räcker det med att hänvisa till den generiska proceduren i huvudprogrammet, och arten av de utförda operationerna kommer att bero på vilken typ av data som erbjuds till proceduren för bearbetning. Alla inbyggda funktioner och subrutiner är gjorda enligt denna princip, till exempel COS(x). Överbelastning av procedurer, funktioner och operatörer (desutom kan programmeraren erbjuda sina egna symboler för överbelastade operatörer, förutom inbyggda) gäller inte bara för inbyggda datatyper, utan även för typer definierade av programmeraren [12] .

Typer av subrutiner

Procedurerna är indelade i subrutiner och funktioner . Subrutiner är bekvämare när du behöver returnera ett stort antal heterogena resultat; funktioner - när du returnerar ett resultat av en typ (inklusive en array).

Ett underprogram definieras av beskrivningsoperatorn Subroutine subprogram_name (lista med formella argument) , en funktion definieras av operatorn Function function_name (lista med formella argument) .

En subrutin anropas av påståendet Call subrutinnamn (lista över faktiska argument) . En funktion anropas med namn, med en lista över faktiska argument och utan att använda någon speciell operator.

Från och med F'90-standarden stöds rekursiva procedurer (inte tillgängliga i tidigare versioner på grund av begränsat maskinminne) som kräver en explicit specificator för att deklarera recursive. I det här fallet måste resultatet av funktionen skilja sig från namnet på själva funktionen.

Rena procedurer och funktioner ( pure subroutine [function]) är procedurer och funktioner som introduceras av F'95-standarden som inte har biverkningar. En ren funktion måste returnera ett värde och får inte ändra någon av dess inmatningsparametrar och/eller globala data; en ren procedur bör endast ändra de parametrar som är explicit specificerade som resultat (output) med hjälp av attributet intent(outeller inout)). Möjligheten till biverkningar i Fortran (det vill säga så småningom möjligheten att ändra variabler i huvudprogrammet genom en subrutin) är en bieffekt av den snabba metoden att skicka till en adress.

Rena programenheter kan inte innehålla I/O-satser ( WRITEoch READ) till externa filer och enheter, inklusive tangentbordet och skärmen, samt programpaus- och stoppsatser.

Alla inbyggda funktioner och subrutiner i Fortran, inklusive matematiska (förutom de som kommer åt operativsystemet, datum- och tidsfunktioner och slumptalsgeneratorer) är rena, det vill säga de skapar inga biverkningar. Rena funktioner introducerades för att förbättra programmeringskulturen och öka effektiviteten av parallellisering av algoritmer [25] [9] .

Underprogramsargument

Underprogramargument kan vara alla inbyggda datatyper, inklusive arrayer och deras sektioner, pekare och programmerardefinierade typer. Subrutinargument kan också vara funktioner och andra subrutiner, förutom interna subrutiner, operatörsfunktioner, generiska (generiska) procedurer (endast specifika namn är tillåtna) och vissa andra inbyggda typer.

Argumenten delas in i formella och sakliga . Argument är omgivna inom parentes efter subrutinnamnet och separerade med kommatecken. Namnen på de faktiska och formella argumenten kan vara desamma.

Formella argument  är argumenten för en subrutin (funktion) som anges i dess beskrivning. Om subrutinen inte har några argument kan parentesen utelämnas. Funktionen har parentes även om det inte finns några formella argument. En formell parameter-procedur kallas en formell procedur .

Faktiska argument  är argument som skickas till en subrutin eller funktion som ska köras när den anropas. En funktion utan argument anropas med en tom lista inom parentes, en subrutin utan parentes.

Formella och faktiska argument måste vara konsekventa . Typerna av argument och varianterna av deras utseende måste vara desamma, arrayen måste motsvara en array (eller sektion av en array) med samma konfiguration.

Det finns arrayer som accepterar konfiguration och storlek som formella argument för procedurer. En konfigurationstagande array  är ett formellt arrayargument som ärver konfigurationen av dess motsvarande faktiska array. För en sådan array, när den deklareras, sätts dimensionen (sammanfaller med dimensionen för det faktiska arrayargumentet) och de övre gränserna utelämnas. Som standard är de nedre gränserna 1, men kan ställas in godtyckligt. Antalet och värdet på elementen i arrayen som tar över konfigurationen ärvs exakt från det faktiska arrayargumentet. En array som antar en storlek  är ett tidigare, inbyggt Fortran'77-språkssätt att beskriva ärvda arrayer, behållet för kompatibilitet. För sådana matriser ärvs endast den sista dimensionen, vars övre gräns beskrivs med en asterisk ( *). I det här fallet kan de formella och faktiska array-argumenten ha olika dimensioner. Matriser som antar en konfiguration och storlek kan inte vara dynamiska eller vara pekare. Procedurer som ärver arrayer måste ha ett explicit gränssnitt.

Formella argumentsträngar kan också ärva (ta över) längden från motsvarande faktiska strängargument. Strängar som får en längd beskrivs med symbolen *: Character (Len = *) string_name . När du uttryckligen anger längden på en sträng kan längden på det strängformella argumentet inte vara större än motsvarande faktiska strängargument.

Argument är positionella och viktiga . Positionella formella och faktiska argument associeras med varandra i den ordning de visas i argumentlistan, som måste matcha. Nyckelord  - efter namnet på nyckeln, som matchar namnet på det formella argumentet. Nyckelord låter dig bryta ordningen på argumenten eller hoppa över några av dem. Så, för en subrutin med rubriken SubroutineONE (A, B, C, D), kan anropet vara: CallONE (D= Z , C= Y , B= X , A= W ), där W, X, Y, Z  är de faktiska argumenten.

Nyckelargument låter dig ha valfria argument som kan utelämnas. I det här fallet måste de valfria argumenten ha Optional. Till exempel, om Optional C, DCall anges kan ONE (B= X , A= W ) anropas i detta fall .

Procedurer med valfria parametrar måste ha ett explicit gränssnitt.

Arbeta med arrayer

Arrayer är centrala i Fortrans filosofi. Alla språkkonstruktioner, data, programenheter, operatorer, inbyggda funktioner, loopar har skapats och är skapade för effektiv bearbetning, först och främst av arrayer. Fortran, som det utvecklas, följer principen att undvika detaljerad (element-för-element) beskrivning och bearbetning av arrayer så mycket som möjligt. Detta är särskilt effektivt vid bearbetning av flerdimensionella arrayer (den maximala dimensionen för arrayer i F2008-standarden är 15). Denna syn på arrayer var inte vanlig för tidiga versioner av språket; de första elementen i ett generaliserat tillvägagångssätt för arrayer dök upp i FORTRAN77; de utvecklas fortfarande.

Matriser är antingen statiska eller dynamiska . Dynamisk är uppdelad i placerad och automatisk (bildas när en subrutin anropas). Elementen i en tvådimensionell array i Fortran är ordnade efter kolumner , inte efter rader, som till exempel i C. Således ändras det första indexet i arrayen snabbast. För att effektivt arbeta med arrayer i kapslade slingor bör du därför indexera de inre slingorna med vänster index och de yttre slingorna med höger index. Som standard tilldelas matriser, inmatning, utdata och initiering kolumnvis.

gör k = 1 , 10 gör j = 1 , 20 gör i = 1 , 100 arr ( i , j , k ) = 25 ! höger brr ( k , j , i ) = 0 ! fungerande, men flera gånger långsammare slut göra ; slut göra ; slut göra

Matriser kan vara av noll storlek (inklusive om den nedre gränsen överskrider den övre). Arraygränsindex kan vara vilka heltal som helst. Den nedre standardgränsen är 1.

Real , allocable :: ArR (:,:,:) ! deklaration av en allokerad dynamisk reell array Heltal , allokerbar :: ArI (:), ArSI ( 2 , 5 ) ! heltals dynamiska och statiska arrayer Tecken ( 32 ), allokerbar :: ArC (:), ArC2 ( 20 ) ! en dynamisk array av strängar med en längd på 32 tecken och en statisk array av strängar Tilldela ( ArR ( - 74 : 0 , 8 , 1 : 3 ), ArI ( 0 ), ArC ( 1 : - 1 )) ! placering av dynamiska arrayer print * , storlek ( ArR ), storlek ( ArI ), storlek ( ArC ), storlek ( ArSI ) ! 1800 0 0 10 ArC2 ( 17 )( 5 : 27 ) = 'Detta är en strängtilldelning' ! Rad nummer 17 kommer att skrivas ␣ ␣ ␣ ␣ Detta är strängens␣ tilldelning␣ ␣ ␣ ␣ ␣ ... Sektioner av arrayer, operatorer FORALLoch WHERE

Fortran tillåter effektiv tilldelning av arrayer utan loopar genom att maskera tilldelningen med hjälp av operatorerna WHEREoch FORALL, såväl som array-slicing och vektorindex . I alla fall utvärderas den högra sidan av hela uttrycket initialt (för alla arrayindex) och först därefter utförs tilldelningen för index som uppfyller maskarrayen. Beräkningar med dessa verktyg låter dig öka prestandan och göra det lättare för kompilatorn att välja delar av programmet som kan köras oberoende, det vill säga parallelliseras.

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 / ! eller Real :: frr1 ( 10 ) = ( / 1 , 2 , 3 , 4 , 4 , 4 , 5 , 5 , 5 , 5 / ) ... arr = 1. ! array-tilldelning (inbyggd överbelastning för tilldelningsoperatör) arr1 = Sin ( arr ) + arr ! den elementära sin-funktionen appliceras på varje element i arrayen arr2 ( I1 : I2 : 1 , J1 : J2 : 2 , K2 : K1 : -4 ) = arr1 ( I1 : I2 : 1 , J1 : J2 : 2 , K2 : K1 : -4 ) ! _ _ elementtilldelning i steg om 1, 2 och -4 (bakåt) ges av en indextriplett frr = ( / ( J , J = 1 , 100 ) / ) ! tilldela en endimensionell array via en cirkulär lista Forall ( i = I1 : I2 , j = J1 : J2 , k = K1 : K2 , arr ( i , j , k ) > 0. ) brr ( i , j , k ) = Log ( arr ( i , j , k ) )) ! byte av cykler och villkorliga uttalanden och konstruktioner. Tilldelningsmaskering (mask — arr(i,j,k)>0.) Förallt ( i = 1 : N , j = 1 : N , k = 1 : N ) crr ( i , j , k ) = Sin ( 0,5 * ( i + j ) -k ) ! _ förlängning av tvärsnitt Förallt ( i = 1 : 100 ) ! Förall konstruktion för flera tilldelningssatser drr ( i , i ) = 0. ! tillgång till diagonalen för matrisen err ( i , i , i ) = 1. ! och diagonaler för en tredimensionell array End Forall

Mindre uppenbara operationer är möjliga:

Heltal V ( -2 : 2 , 1 : 5 ) _ V = omforma ( källa = ( / ( i , i = 1 , 25 ) / ), form = ( / 5 , 5 / )) ! initiering av en array med serienummer med hjälp av arraykonstruktorn och omformningsfunktionen print * , V ! Utdata till DOS-fönstret kommer att göras rad för rad ! 1 2 3 4 5 - 1:a kolumnen ! 6 7 8 9 10 - 2:a ! 11 12 13 14 15 - 3:a ! 16 17 18 19 20 - 4:a ! 21 22 23 24 25 - 5:e V ( 2,3 : 4 ) = V ( -1 : 0,1 ) ! _ _ _ _ _ Rotera en bit av array print * , V ! Utdata till DOS-fönstret kommer att göras rad för rad ! 1 2 3 4 5 ! 6 7 8 9 10 ! 11 12 13 14 2 ändra i 3:e kolumnen 15 till 2 ! 16 17 18 19 3 ändra i 4:e kolumnen 20 till 3 ! 21 22 23 24 25

Operatörens och konstruktionens möjligheter som FORALLintroduceras av F'95-standarden är bredare än operatörens och konstruktionens WHERE, men den senare, i vissa fall av logisk förgrening, låter dig förenkla koden på grund av närvaron av ett alternativ ELSEWHERE, undviker kapslade villkorliga operatorer och komplexa maskmatriser.

Operatören och konstruktionen FORALLtillåter endast att rena procedurer och funktioner används . Vid maskering av tilldelningen i operatorerna WHERE, FORALLsamt i speciella inbyggda funktioner för arrayer (till exempel SUM), beräknas den logiska array-masken före tilldelningen och låter dig ersätta slingor med logiska villkor inuti dem, vilket undviker ytterligare arbete för mikroprocessorgrenprediktorn .

Ett vektorindex  är en heltals endimensionell array vars värden är indexen för någon annan array. Vektorindex används för att skapa godtyckliga sektioner av flerdimensionella arrayer och är deras generaliseringar. När du använder vektorindex bör du se upp för upprepade indexvärden på vänster sida av tilldelningsoperatorn, eftersom i detta fall ett försök kommer att göras att skriva eventuellt olika värden till en minnescell. Ordningen på indexen är godtycklig (även om detta inte bör överanvändas för att undvika prestandaförsämring).

Heltal vi ( 5 ) / 7 , 7 , 7 , 3 , 8 / , vj ( 4 ) / 1 , 2 , 3 , 10 / ! initiering av arrayer - vektorindex Real arr ( 20 , 20 ), brr ( 10 , 10 ) brr = 0. ; arr = 1. ! vektorindex kan också specificeras inuti arrayen som använder dem brr (( / 8 , 6 , 2 , 1 , 4 / ), vj ) = arr ( vi , vj ) ! dimensionerna för vektorindex måste matcha till vänster och höger, och deras värden får inte gå utanför gränserna för de arrayer som använder dem ! storleken på vektorindex kan vara mindre än storleken på arbetsmatriser Inbyggda funktioner för arrayer

Modern Fortran har ett stort antal specialiserade inbyggda funktioner för att arbeta med numeriska och teckenuppsättningar (utöver de allmänna metoderna som diskuterats ovan). Funktionernas argument är den numeriska och/eller teckenmatrisen , den logiska arraymasken ( som till exempel är villkoret array>0 ) och dimensionen dim för arraymatrisen , som bildas (om dim- argumentet ges ) en sektion av arrayen längs en av dimensionerna med numret dim . Matrisen kan , om inte annat anges, vara heltal, innehålla reella eller komplexa tal. Om maskmatrisen inte anges anses dess värde vara identiskt sant. Den booleska arraymasken , om den ges, måste ha samma form som array , eller ett skalärt värde .TRUE..
Huvuddelen av funktionerna som introduceras av F'90-standarden.

ALL(mask[, dim]) är en logisk funktion; returnerar "true" om alla element i den logiska arraymasken är sanna (längs den valfria dimensionen dim ) och vice versa annars.
ANY(mask[, dim]) är en logisk funktion; är sant om minst ett element i den logiska arraymasken är sant (längs den valfria dimensionen dim ).
COUNT(mask[, dim]) är en heltalsfunktion; resultatet är lika med antalet sanna element i maskarrayen (längs den valfria dimensionen dim ).

MAXLOC(array[, mask][, dim]), MINLOC(array[, mask][, dim]),
 är heltalsfunktioner som returnerar indexet för max- och minimumelementet (eller index för max- och minimumelementen) längs den valfria dimensionen dim för element som uppfyller maskuppsättningen. Funktionerna returnerar indexet för det första elementet i arrayen . Om argumentet för dimfunktion inte ges, eller om array  är en endimensionell array, skrivs resultatet till en endimensionell array.
För flerdimensionella arrayer array skrivs resultatet till en array med en rankning som är ett mindre än array arrayens rang ( dim är utesluten ).

Indexvärdena räknas i ordning från de nedre gränserna för arrayen. Det vill säga, om numret på den nedre gränsen för array -matrisen skiljer sig från en, då för att komma åt max- eller minimumelementet i matrisen, bör man lägga till resultatet av funktionerna MAXLOCskillnaden MINLOCmellan indexet för den nedre gränsen och en .

MAXVAL(array[, mask][, dim]), MINVAL(array[, mask][, dim]) — sökfunktioner för max- respektive minimumelementet i array -matrisen för element som uppfyller den logiska mask-matrismasken längs den valfria dimensionen dim . Resultatet av funktionen är samma typ och variation som array . Matrisen kan bara vara reell eller heltal.
För en endimensionell array , eller om det inte finns något svagt argument , är resultatet en skalär, annars en array med en rankning som är ett mindre än rank of array .

FINDLOC(array, value[, dim][, mask]) är en heltalsfunktion som returnerar indexet för matriselementet lika med värde . Introducerad av F2008-standarden. De sökta arrayelementen uppfyller den logiska mask array- masken längs den valfria dimensionen dim . Typen av värdeargumentet måste matcha typen av array och kan vara vilken inbyggd typ som helst (inklusive komplex, boolesk eller tecken). Funktionens återstående egenskaper liknar egenskaperna för funktionerna och . MAXLOCMINLOC

Från och med F2003-standarden, fungerar funktionerna MAXLOCoch MINLOC, liksom funktionen FINDLOC, också på teckendata.

SUM(array[, mask][, dim])och PRODUCT(array[, mask][, dim])utföra, respektive, summeringen och multiplikationen av elementen i arrayen. Innebörden av funktionsargumenten är SUMdensamma PRODUCTsom för ovanstående funktioner.
Funktionen PRODUCTarbetar på komplexa data från F2003-standarden.

DOT_PRODUCT(vector_1, vector_2)utför en inre produkt enligt reglerna för linjär algebra för vektorer vektor_1 och vektor_2 (endimensionella arrayer) av samma storlek. Endimensionella arrayer vector_1 och vector_2 kan innehålla data av vilken numerisk och boolesk typ som helst. Vektorerna vektor_1 och vektor_2 kan antingen vara både numeriska eller båda booleska.

MATMUL(matrix_a, matrix_b) - Inbyggd matrismultiplikationsfunktion. Multiplicerar två matriser, en matris med en vektor, en vektor med en matris enligt reglerna för linjär algebra. Funktionsargumenten matrix_a och matrix_b  är tvådimensionella eller endimensionella numeriska (av alla inbyggda numeriska typer) eller logiska arrayer. Funktionsargument kan inte vara två vektorer samtidigt: ett av argumenten måste vara en matris (tvådimensionell matris). Antalet element i den första (eller enda) dimensionen av matrix_b- matrisen måste vara lika med antalet element i den sista dimensionen av matrix_a- matrisen . Introducerad av F'90-standarden. I vissa fall, när man beräknar produkten av en kolumnvektor med en radvektor, vilket kräver en ytterligare transformation av vektorer till matriser av formen och när man använder funktionen , är effektiviteten enligt Barteniev [12] märkbart sämre än en konventionell kapslad loop. Enligt NASA-tester [26] för produkten av matriser (tvådimensionella arrayer) överstiger prestanda hos Intel-kompilatorn när den fullständiga optimeringen -O3 används avsevärt (i vissa fall i en storleksordning) prestandan för kapslade loopar , även om det för matriser med en storlek på ~1000 × 1000 och större är något sämre än prestandasubrutinerna DGEMM i LAPAK- biblioteket . Samtidigt, för matriser ~100×100 och mindre , överträffar den DGEMM när det gäller hastighet. IBM Fortran-kompilatorn, som börjar med version F'90, använder Winograd-Strassen-algoritmen med komplexitet [27] för det . Observera att de algoritmiska implementeringarna av matematiska funktioner vanligtvis inte specificeras av standarden och förblir efter kompilatorutvecklarens gottfinnande.
MATMUL(/m,1/)(/1,n/)MATMUL
MATMULMATMULMATMUL

MERGE(t_source, f_source, mask) — en funktion som skapar en ny array under kontroll av mask-array- masken från elementen i t_source- och f_source-arrayerna med samma form och storlek som de ursprungliga arrayerna. Argumentmatriserna och resultatmatrisen kan vara av vilken inbyggd typ som helst och matcha i datatyp, storlek och form.
Om maskelementet är sant ( .ТRUE.), är motsvarande element i resultatmatrisen lika med motsvarande element i t_source- matrisen ; om false ( .FALSE.) — sedan till elementet i arrayen f_source .
Funktionsargument kan vara skalärer; i detta fall till exempel MERGE(a,0,c>=0)=a· Θ(с) , där Θ(с)  är en heltal Heaviside-funktion .

MOVE_ALLOC(from, to) är en inbyggd subrutin som låter dig dynamiskt omallokera en tidigare allokerad dynamisk array till med nya gränser och storlek, som den dynamiska arrayen från . Data från från -matrisen kopieras till till -matrisen . Datatypen och rangordningen för från- och till -matriserna måste matcha. Efter att till -matrisen har omfördelats frigörs från -matrisen och blir oallokerad. Det kan vara användbart i numeriska metoder med varierande diskretisering av problemet ( multigrid och adaptiva metoder).
Introducerad av F2003-standarden.

TRANSPOSE(matrix) är en funktion som transponerar (byta rader och kolumner) en tvådimensionell matris.

Modern Fortran tillhandahåller inbyggda funktioner för att packa och packa upp en flerdimensionell array till en endimensionell array (respektive från en endimensionell array) under kontroll av ett logiskt villkor för att förbättra prestanda och spara minne.

PACK(array, mask [, vector]) - funktion; packar en flerdimensionell array av valfri arraytyp i en endimensionell vektor array som kontrolleras av den logiska arraymasken . Den valfria endimensionella arrayvektorn måste vara av samma datatyp som array , och antalet element i vector , om det ges, måste vara minst lika många som antalet sanna element i mask . Om mask  är en skalär med värde måste antalet element i vektormatrisen.TRUE. , om det ges, vara minst lika stort som det totala antalet element i matrisen . Resultatet av funktionen blir en endimensionell array av samma typ som array . Längden på resultatet kommer att vara lika med längden på vektor , om en ges; om inte, då antalet sanna element i maskarrayen . Om vektorn inte anges och masken  är en skalär med värdet true , är längden på den resulterande endimensionella vektorn lika med antalet element i array . Den resulterande matrisen fylls sekventiellt med matriselement ( i den ordning som de placeras i datorns minne) som uppfyller de sanna värdena för maskmatrisen . I det här fallet, om en vektor ges , väljs de saknade (möjligen) elementen i resultatmatrisen från den, och börjar från indexet efter det sista sanna elementet i matrismatrisen i ordning . Så för en array blir resultatet av funktionen en endimensionell array . Om en vektor dessutom ges blir resultatet .



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

Filer och I/O

Fortran har rika inbyggda verktyg för input-output-operationer, inklusive för stora datamatriser. Filer i Fortran är interna och externa.

En intern fil  är valfri array, teckensträng eller delsträng. Interna filer är alltid öppna som standard. En extern fil  är vilken fil som helst som är extern i förhållande till programmet som körs.

Båda filtyperna använder samma skriv- WRITEoch läsoperatorer READ. Interna filer används för siffer-sträng-tal-konverteringar och för att skapa blandade numeriska och teckenposter.

Tecken ( 15 ) sträng Real :: xyz =- 12 3,456 Heltal intg Skriv ( sträng , * ) xyz ! Skriv nummer -123.456 till sträng Skriv ut * , 'string=' , sträng ! string=␣ -123.4560␣ ␣ Läs ( sträng , '(I6)' ) intg ! Läsa ett heltal från en sträng Skriv ut * , 'intg=' , intg ! intg=␣ -123 !...

Externa filer är uppdelade i formaterade (text-, CR- och LF-strömmar), binära (binära), direktvisande RAM-minne och oformaterad (icke-binär). Dessutom kan de vara direkta och sekventiella åtkomstfiler med poster med fast och variabel längd (variabel endast för sekventiella filer), såväl som segmenterade poster (för mycket stora oformaterade sekventiella filer). Således låter Fortran dig skapa och bearbeta ett ganska stort antal typer av filer - 15 sätt att organisera. Den maximala storleken på en post är 2,14 byte.

Direktåtkomstfiler låter dig utföra I/O-operationer på poster med ett givet nummer (utan att skriva över de högre eller lägre posterna i filen).

När du öppnar en sekventiell fil kan den placeras i början, i slutet (innan du skriver "filslut"), vilket gör att du kan lägga till data allt eftersom de ackumuleras utan att skriva över tidigare inmatade, såväl som antingen i början eller i slutet, beroende på den tidigare definierade filstatusen (var den öppen tidigare eller inte).

Arbeta med minne

I moderna språkstandarder (som börjar med Fortran'90 eller Fortran'95) är det möjligt att arbeta med tre typer av dynamiska arrayer (automatiska, allokerade och referensarrayer), pekare , länkar ; det finns inbyggda procedurer för att arbeta med minne direkt och procedurer för bitvisa operationer.

Språkstandarderna förutsätter automatisk frigivning av RAM-minne som upptas av vilken typ av dynamisk array som helst efter att programmet eller subrutinen (procedur, funktion) har slutförts, även om frigivningen inte utfördes explicit av programmeraren. Detta gör att du kan undvika minnesläckor när du arbetar med dynamiska arrayer med Fortran (när du använder pekare och i andra fall är läckor möjliga) med slarvig programmering [12] .

Automatiska arrayer (placerade av kompilatorn) skapas när en subrutin anropas och är dess lokala objekt. Deras gränser definieras varje gång proceduren åberopas; samtidigt, när du lämnar den, förstörs de, och minnet rensas. Automatiska arrayer finns på stacken under körningen av programmet , allokerade (med operatören ALLOCATE) - på högen [25] .

Fortran-pekare liknar C-pekare [12] , men när man löser beräkningsproblem och utvecklar matematiska algoritmer ersätts de i de flesta fall framgångsrikt av andra Fortran-verktyg.

Kontrollstrukturer

Från och med F'90-standarden skiljer sig den villkorliga grenkonstruktionen IF THEN - ELSEIF THEN - END IFinte från liknande konstruktioner på andra moderna språk och ersatte den så kallade. "arithmetic" IFmed etiketter, utfasad [9] . Det finns också en enklare form av den villkorliga operatorn: , där den körbara operatorn måste vara den enda efter operatorn , till exempel . IF(логическое условие) операторIFGoto метка

Valkonstruktionen SELECT CASE - CASE - CASE DEFAULT - END SELECTskiljer sig tvärtom från konstruktionen SWITCH - CASEi C-liknande språk [28] , Java-språk [29] [30] och påminner något om operatören CASEi Pascal [31] när det gäller dess möjligheter .

Heltal N ( 74 ) ! välj uttryck är ett heltal, logiskt, teckenuttryck eller ... ! heltalsmatris, eller teckenmatris med valfritt antal element som inte är noll nameSC : Välj Case ( N ( i )) ! nameSC — konstruktionsnamn, N(i) — arrayelement Fall ( : -5 ) ! utförs för alla N(i) mindre än eller lika med -5 med ett steg på +1 ! Block 1 Fall ( -3 , -1 , 0 , 2 ) ! _ _ för variabel N(i) lika med -3, -1, 0, 2 ! Block 2 Fall ( 50 : 100 ) ! för N(i) i intervallet från 50 till 100 inklusive (steg +1) ! Block 3 Fodral ( 400 ) ! för N(i)=400 ! Block 4 Fall ( 1 , 20 : 30 , 35 ) ! för N(i)=1, N(i) i intervallet från 20 till och med 30 och N(i)=35 ! Block 5 Fall standard ! för alla andra situationer. Case Default - valfritt, valfritt uttalande ! Standardblock Slut Välj namnSC

Om värdet på variabeln N, kallat urvalsuttrycket, matchar listan med väljare (lista med värden eller intervall) i någon sats CASE, till exempel i den tredje för N=70 , då, efter att ha kört motsvarande block av påståenden Block-3 , konstruktionsutgångarna SELECT CASE[12] [25] och avbrottssatser (som BREAK) krävs inte . Operatören CASE DEFAULT, liksom namnet på konstruktionen, är inte nödvändigt. Områden i väljarlistor för olika operatörer CASEfår inte överlappa eller ha minst ett gemensamt element.

Valuttrycket (N) kan vara ett element i en heltalsmatris.

Områden i väljarlistor gäller endast heltal eller tecken, i stigande ordning från botten till toppen; för tecken - i stigande ordning efter sina koder .

I moderna Fortran finns det två former av loopar med en iterationsräknare: den traditionella konstruktionen och DOden ENDDOmärkta loopen. Den senare har erkänts som en föråldrad design sedan F'90-standarden, men ingår fortfarande i standarderna. För kapslade slingor med mer kapsling kan den sista formen vara mer kortfattad:

! Syntax för den föråldrade loopkonstruktionen gör 1 k = 1 , 10 ! 1 är slutet av slingan gör 1 j = 1 , 20 ! etiketten kan vara densamma för kapslade loopar gör 1 i = 1 , 100 arr ( i , j , k ) = 25 1 Fortsätt ! etiketten kan bara visas framför någon operatör L1 : gör k = 1 , 10 ! men modern notation låter dig namnge cykler, L2 : gör j = 1 , 20 ! vilket är mer i linje med begreppet strukturerad programmering L3 : gör i = 1 , 100 ! och gör det lättare att undvika misstag arr ( i , j , k ) = 25 avsluta till L3 avsluta till L2 avsluta till L1

Slinghuvudet med en räknare har följande fullständiga form:

namn : DO I = N1 , N2 , dN ! konstruktionens namn är valfritt ... ! N1 är startvärdet för räknaren, N2 är slutvärdet, dN är steget (loopparametrar) END DO name ! Slingparametrarna är heltal med godtyckligt tecken. dN är icke-noll.

Antalet exekveringar av slingkroppen utan avbrott är Nc = ( max( int(N2 - Ni + dN )/dN), 0 ) och kan vara lika med noll.

Till exempel kommer loopen att utföras noll gånger om N 2 <N 1 och steget är positivt: dN>0 . Om steget är negativt, dN<0, kommer cykeln att gå i omvänd ordning , medan det för att slutföra cykeln är nödvändigt att N2 < N1 . Om steget dN utelämnas, anses det som standard vara lika med ett: dN=1 .

Värdet på loopvariabeln I efter att ha lämnat den är alltid lika med N s +1 , det vill säga en mer än antalet iterationer av loopen och inte mindre än en: I≥1.

Det är också möjligt att ha en villkorlig loop  - , och en oändlig loop  - , som har en standardform. DO WHILE(логическое условие)END DODOEND DO

Operatören CYCLE имя циклаavbryter den aktuella iterationen av slingan och fortsätter till nästa iteration av samma slinga. Om slingnamnet inte anges, avbryts iterationen av den aktuella slingan (där operatören befinner sig CYCLE).

Operatören EXIT имя циклаavbryter exekveringen av slingan med det angivna namnet och överför kontrollen vidare, och om det inte finns något namn, avbryter den den aktuella slingan (i vilken operatören är kapslad EXIT).

Operatörerna CYCLEoch är EXITlogiskt identiska med en operatör GOTO(under lämpliga omständigheter), men gör koden mycket lättare för programmeraren att förstå och underhålla.

Kompilatorer

Sedan den första utvecklingen av språket har Fortran- kompilatorer tillverkats av IBM. För närvarande levererar IBM VS Fortran -optimeringskompilatorn [32] för IBM System z stordatorer , vars utvecklingshistorik för olika versioner går tillbaka till 1964, såväl som XL Fortran-kompilatorn [33] för plattformar baserade på PowerPC- arkitekturen  - AIX , Linux och superdator Blue Gene (det fanns även en version för Mac OS X , när Macintosh-datorer använde PowerPC-processorer). Båda dessa kompilatorer innehåller mycket sofistikerade optimerare, resultatet av ett halvt sekel av kontinuerligt vetenskapligt arbete av IBM-specialister. På basis av IBM Fortran XL-kompilatorn har Absoft, en IBM-affärspartner, skapat och levererar Absoft Pro Fortran-kompilatorn för system baserade på PowerPC (Linux, Mac OS X) och Intel (Linux, Mac OS X, Windows)-processorer [34] .

Fram till 1997 var Microsoft Corporation en stor tillverkare av Fortran-kompilatorn för Windows-operativsystemet . Därefter övergav hon deras utveckling på grund av låg lönsamhet. Därefter levererades kompilatorn av DEC , som blev en del av Compaq 1998 och tillsammans med den senare slogs samman med HP 2002 . Den här versionen av kompilatorn utvecklades vidare av Intel , och kompilatorn heter Intel Fortran Compiler , vilket låter dig optimera kod för Intel IA-32, x86_64 och IA-64-plattformarna.

DEC tillhandahåller en kompilator integrerad i Digital Visual Fortrans utvecklingsmiljö baserad på Microsoft Visual Studio . De mest kända produkterna i denna linje är FPS 4.0 (Microsoft Fortran Power Station), DVF 5.0 och 6.0. Varje kompilator kan stödja flera Fortran-standarder. Sammanslagningarna gjorde att efterföljande produkter kom ut på marknaden under varumärkena Compaq och HP. HP säljer för närvarande en utvecklingsmiljö version 6.6 för Intel/win32. Fortran-stöd är också implementerat för alla HP:s högpresterande plattformar.

En annan stor leverantör av Fortran utvecklingssystem är Lahey , som erbjuder integrerade lösningar för Windows och Linux.

Under lång tid ansågs Watcom- kompilatorn vara den bästa Fortran-kompilatorn för PC , som separerades i ett separat Open Watcom- projekt , som utvecklar kompilatorn på en öppen basis.

Bland de gratis Fortran-kompilatorerna bör man lyfta fram kompilatorn från det tidigare Sun Microsystems (numera Oracle), som är en del av Sun Studio , som genererar effektiv kod under SPARC , x86 och x86-64 [35] och är tillgänglig för Solaris , OpenSolaris och GNU/Linux .

GNU Free Software Foundation släppte kompilatorn g77 Fortran 77, som är öppen källkod och tillgänglig för nästan alla plattformar och är helt kompatibel med GCC . Nu har den ersatts av GFortran- kompilatorn , som implementerar nästan alla konstruktioner av Fortran-95-standarden och många av konstruktionerna av Fortran-2003, Fortran-2008 och Fortran-2018-standarderna. Den är också helt bakåtkompatibel med Fortran-77. Det finns också ett oberoende g95- projekt för att skapa en Fortran-95-kompilator baserad på GCC .

Interaktion med andra språk

Många programmeringssystem låter dig länka objektfiler som erhållits som ett resultat av översättning av ett Fortran-program med objektfiler som erhållits från kompilatorer från andra språk, vilket gör att du kan skapa mer flexibla och multifunktionella applikationer. Ett stort antal bibliotek finns också tillgängliga för Fortran-språket, som innehåller både rutiner för att lösa klassiska beräkningsproblem ( LAPACK , IMSL , BLAS ), uppgifter för att organisera distribuerad datoranvändning ( MPI , PVM ), och uppgifter för att bygga grafiska gränssnitt ( Quickwin , FORTRAN ). /TK ) eller tillgång till DBMS ( Oracle ).

Fortran i USSR

Fortran dök upp i Sovjetunionen senare än i väst, eftersom Algol först i Sovjetunionen ansågs vara ett mer lovande språk . Kommunikationen mellan sovjetiska fysiker och deras kollegor från CERN , där på 1960-talet nästan alla beräkningar utfördes med Fortran-program, spelade en viktig roll i införandet av Fortran [36] .

Den första sovjetiska Fortran- kompilatorn skapades 1967 för Minsk-2- maskinen , men den fick inte mycket berömmelse. Den utbredda introduktionen av Fortran började efter skapandet 1968 av FORTRAN-DUBNA-kompilatorn för BESM-6- maskinen . Fortran är huvudspråket för ASVT- och SM-datorer , som ofta används tillsammans med RATFOR- förprocessorn . ES -datorerna som dök upp 1972 hade redan från början en Fortran- översättare ("lånad" från IBM/360 tillsammans med annan programvara).

På 1970-talet utvecklade IPM det grafiska biblioteket GRAFOR ("Graphic Extension of FORtran") [37] .

I slutet av 1980-talet och början av 1990-talet skapade fysikern Andrei Zaretsky en serie barnböcker, vars en av huvudpersonerna var professor Fortran , som förklarade grunderna för datorkunskap och programmering för barn på ett tillgängligt språk [38] [39] .

Anteckningar

  1. ↑ 1 2 3 4 Historia om FORTRAN I, II och III - Journal of the ACM , 1981.
  2. ↑ V.E. Karpov. KLASSISK KOMPILERSTEORI. - Handledning. 2:a upplagan - Moskva, 2011. - 91 sid. - ISBN 5-230-16344-5.
  3. ↑ Plankalkül - språket , som påstår sig vara palmen, uppfanns redan 1945, men implementerades inte förrän 2000.
  4. ↑ Ordbok över främmande ord. - M .: " Ryskt språk ", 1989. - 624 sid. ISBN 5-200-00408-8
  5. ↑ Se till exempel: Netlib Repository på UTK och ORNL Arkiverad 27 juli 2021 på Wayback Machine
  6. ↑ IMSL Fortran Numerical Library | Rogue våg . Hämtad 19 augusti 2015. Arkiverad från originalet 16 augusti 2015.
  7. ↑ Barteniev O.V. 1-3 // Fortran för proffs. ISML matematiska bibliotek. - Moskva: Dialog-MEPhI, 2001. - p1 - 448 s., p2 - 320 s., p3 - 368 s. - 3000 exemplar.  - ISBN 5-86404-157-2 (del 2), 5-86404-18-58-0 (del 3).
  8. ↑ 1 2 3 4 5 6 7 8 9 A. M. Gorelik . Utveckling av programmeringsspråket Fortran (1957—2007) och framtidsutsikter för dess utveckling // Computational methods and programmering, 2008, vol. 9, sid. 53-71 Arkiverad 2 april 2015 på Wayback Machine
  9. ↑ 1 2 3 Gorelik A.M. Del 2, kapitel 14-20 // Programmering i modern Fortran. - Moskva: Finans och statistik, 2006. - 352 s. - 3000 exemplar.  — ISBN 5-279-03066-X .
  10. ↑ ANSI. X3.9-1966 - FORTRAN . — 1966. Arkiverad 1 november 2020 på Wayback Machine
  11. ↑ Fortran 77 - ANSI X3J3/90.4 arbetsgrupp  . Hämtad 18 februari 2021. Arkiverad från originalet 11 november 2020.
  12. ↑ 1 2 3 4 5 6 7 8 Barteniev O.V. Moderna Fortran . - M . : Dialogue MEPhI, 2005. - ISBN 5-86404-113-0 . Arkiverad 10 februari 2011 på Wayback Machine
  13. ↑ Fortran 90 - Sista fungerande utkast  . wg5-fortran.org . Hämtad 18 februari 2021. Arkiverad från originalet 5 november 2020.
  14. ↑ A. M. Gorelik. Objektorienterad programmering i Modern Fortran Arkiverad 7 september 2011 på Wayback Machine
  15. ↑ Fortran 95 - Sista fungerande utkast  . wg5-fortran.org . Hämtad 18 februari 2021. Arkiverad från originalet 1 juli 2021.
  16. ↑ Gorelik A.M. 3. Introduktion till parallell programmering i Fortran // Programmering i modern Fortran. - Moskva: Finans och statistik, 2006. - 352 s. — ISBN 5-279-03066-X .
  17. ↑ 1 2 S. D. Algazin, V. V. Kondratiev. Programmering i Visual Fortran. - M . : " MEPhI Dialogue ", 2008. - 448 sid. — ISBN 5-8243-0759-8 .
  18. ↑ Fortran 2003–Last Working Draft . Gnu.Org. Hämtad 10 maj 2014. Arkiverad från originalet 25 februari 2021.
  19. ↑ Fortran 2008 - Sista fungerande utkast . Gnu.Org. Hämtad 10 maj 2014. Arkiverad från originalet 3 mars 2021.
  20. ↑ Gorelik A. M. News Arkivexemplar av 2 mars 2012 på Wayback Machine
  21. ↑ Fortran 2018 . ISO. Hämtad 30 november 2018. Arkiverad från originalet 1 december 2017.
  22. ↑ Ytterligare interoperabilitet med C. ISO. Hämtad 20 november 2017. Arkiverad från originalet 8 mars 2021.
  23. ↑ Ytterligare parallella funktioner i Fortran . ISO. Hämtad: 20 november 2017.
  24. ↑ Troy Douglas, Douglas A. Troy. per. från engelska. B.A. Kuzmina. Programmering i C för IBM PC = Komplett C-språkprogrammering för IBM-PC / IV Emelin. - Moskva: "Radio och kommunikation", 1991. - 432 s. - ISBN 5-256-00707-6 , 0-316-85311-9.
  25. ↑ 1 2 3 Gorelik A.M. Del 1, kapitel 1-13 // Programmering i modern Fortran. - 1. - Moskva: Finans och statistik, 2006. - 352 s. — ISBN 5-279-03066-X .
  26. ↑ Thomas Clune. Jämför Python, NumPy, Matlab, Fortran, etc. . NASA Modeling Guru (2 nov 2009 10:33). Hämtad 7 oktober 2015. Arkiverad från originalet 23 oktober 2015.
  27. ↑ Craig C. Douglas, Gordon Slishman. Varianter av Matrix-matrix Multiplication for Fortran-90  // SIGNUM Newsl .. - 1994-04-01. - T. 29 , nej. 2 . — S. 4–6 . — ISSN 0163-5778 . - doi : 10.1145/181498.181500 . Arkiverad från originalet den 9 augusti 2021.
  28. ↑ Switch-sats (C++) . msdn.microsoft.com. Tillträdesdatum: 5 juni 2016. Arkiverad från originalet 13 augusti 2016.
  29. ↑ Växelkonstruktionen . learn.javascript.ru. Hämtad 5 juni 2016. Arkiverad från originalet 9 juni 2016.
  30. ↑ Subtiliteter i switch-satsen . habrahabr.ru. Hämtad 5 juni 2016. Arkiverad från originalet 17 juni 2016.
  31. ↑ Fallutlåtandet . www.freepascal.org. Hämtad 5 juni 2016. Arkiverad från originalet 22 maj 2016.
  32. ↑ VS FORTRAN . Hämtad 8 mars 2010. Arkiverad från originalet 9 augusti 2021.
  33. ↑ XL Fortran för Linux . Hämtad 8 mars 2010. Arkiverad från originalet 9 augusti 2021.
  34. ↑ Absoft Pro Fortran Compiler Suites Allmän översikt . Hämtad 8 mars 2010. Arkiverad från originalet 9 augusti 2021.
  35. ↑ Sun Studio - Benchmarks . Hämtad 20 november 2007. Arkiverad från originalet 26 oktober 2007.
  36. ↑ Essä av Alexander Rastorguev om Fortrans uppträdande i Dubna . Datum för åtkomst: 22 januari 2012. Arkiverad från originalet den 10 juli 2014.
  37. ↑ Historia om datorgrafik i Ryssland (otillgänglig länk) . Datum för åtkomst: 8 januari 2012. Arkiverad från originalet den 17 mars 2012. 
  38. ↑ Encyclopedia of Professor Fortran , Sutki.net  (29 januari 2008). Arkiverad från originalet den 10 mars 2012. Hämtad 11 juni 2013.
  39. ↑ Kirilenko, Alexander . Estland introducerar programmering i skolor från lågstadiet , Noosphere  (7 september 2009). Arkiverad från originalet den 9 september 2012. Hämtad 11 juni 2013.

Litteratur

Länkar

  Gå till Wikidata-objektet  I sociala nätverk
Tematiska platser
Ordböcker och uppslagsverk
 Programmeringsspråk