Fortran

Fortran
Semantik imperativ , parallel
Sprog klasse proceduremæssig , modulær , med elementer af objektorienteret programmering
Udførelsestype kompileret
Dukkede op i 1957
Forfatter John Backus , IBM
Udvikler IBM [1] og John Backus [1]
Filtypenavn _ .for .f .f90 .f95
Frigøre Fortran 2018 (ISO/IEC 1539-1:2018) (28. november 2018)
Type system streng , statisk
Større implementeringer GFortran , Open Watcom , Sun Studio , XL Fortran , Intel Fortran
Dialekter Højtydende Fortran
Blev påvirket Hastighedskodning [d]
påvirket ALGOL 68 , BASIC , PL/I
Internet side fortran-lang.org _ 
 Mediefiler på Wikimedia Commons

Fortran ( eng.  Fortran ) er det første programmeringssprog på højt niveau, der har fået praktisk anvendelse, har en oversætter og har oplevet yderligere udvikling [2] . Skabt mellem 1954 og 1957 af en gruppe programmører ledet af John Backus hos IBM Corporation [3] . Navnet Fortran er en forkortelse for FOR mula TRAN slator (formeloversætter) [4] . Fortran er meget udbredt, primært til videnskabelig og teknisk databehandling. En af fordelene ved moderne Fortran er et stort antal programmer og biblioteker af subrutiner skrevet på den [5] .

Der er et stort antal forskellige matematiske biblioteker skrevet i Fortran (for det meste i ældre versioner af sproget) til matrixalgebra og løsning af lineære ligningssystemer , biblioteker til løsning af differentialligninger , integralligninger og deres systemer, tilnærmelse af funktioner , specialfunktioner , hurtige Fourier-transformationer , matematisk statistik og andre matematiske discipliner. Disse biblioteker leveres normalt med compileren. En række af sådanne pakker er blevet skabt gennem årtier og er stadig populære i det videnskabelige samfund den dag i dag, for eksempel International Mathematical Subroutine Library (IMSL) [6] [7] .

De fleste af disse biblioteker er i virkeligheden menneskehedens ejendom: de er tilgængelige i kildekode, veldokumenterede, debuggede og meget effektive.

Modern Fortran (Fortran 95 og Fortran 2003) har erhvervet de funktioner, der er nødvendige for effektiv programmering af nye computerarkitekturer; giver dig mulighed for at anvende moderne programmeringsteknologier, især generisk og modulær programmering , OOP , samtidig med at kontinuiteten med tidligere versioner bevares. Et af hovedkoncepterne for udviklingen af ​​moderne Fortran er parallelismestøtte og vektoroperationer [8] .

Udviklingen af ​​sprogstandarder

Fortran er et højt standardiseret sprog, så det nemt kan overføres til forskellige platforme. De nye sprogstandarder bevarer i høj grad kontinuitet med de ældre, hvilket gør det muligt at bruge koderne for tidligere skrevne programmer og ændre dem [8] . Samtidig med at sproget udvikler sig, annonceres der på forhånd forældede konstruktioner, som kan blive fjernet i fremtiden [9] .

FORTRAN 66 (1966)

ANSI X3.9-1966 -standarden [10] definerede FORTRAN-sproget (baseret på IBMs FORTRAN IV, der fungerede som de facto-standarden). Det blev efterfølgende omtalt som FORTRAN 66, selvom mange fortsatte med at henvise til det som FORTRAN IV, det sprog, som standarden stort set var baseret på.

FORTRAN 77 (1978)

ANSI X3.9-1978, ISO 1539:1980 [11] , mange forbedringer [8] :
  1. Operatorer til åbning og lukning af en fil ( OPEN, CLOSE) og output til en standardenhed - PRINT.
  2. Tilføjet strengdatatype og funktioner til dens behandling.
  3. Blokoperatøren og IF konstruktion IF THEN - ELSE IF THEN - introduceres END IF, samt programfragmentinkluderingsoperatøren INCLUDE.
  4. Introducerede muligheden for at arbejde med filer med direkte adgang.
  5. Den maksimale dimension af et array er blevet øget fra 3 til 7. Begrænsninger på array-indekser er blevet fjernet.
  6. Mulighederne for at arbejde med procedurer er blevet forbedret og udvidet.
  7. Konceptet med en intern fil (som er arrays, numeriske og strengvariabler) er blevet introduceret. Interne filer gør det især muligt at udføre tal-streng og streng-tal konverteringer med standard læse- og skriveoperatorer READog WRITE[12] .

Fortran 90 (1991)

ISO/IEC 1539:1991 (ANSI INCITS 198-1992) [13] reviderede sprogstandarden [12 ] markant, herunder ændring af navnet på FORTRAN til Fortran.
  1. Introducerede et gratis format til at skrive kode. Yderligere beskrivelser dukkede op IMPLICIT NONE, TYPE, ALLOCATABLE, POINTER, TARGET, NAMELIST.
  2. Kontroloperatører og konstruktioner introduceres. Tilføjet DO… END DO(i stedet for at afslutte løkken med en etiket), DO WHILE, kontroloverførselsoperatør til begyndelsen af ​​løkken CYCLE, udvælgelseskonstruktion SELECT CASE(for at erstatte besværlige konstruktioner IFog operatører GOTO), samt den endelige operatør af en programenhed, modul eller intern procedure END[8] .
  3. Introducerede pointerværktøjer og funktioner til at arbejde med RAM (i analogi med C-sproget).
  4. Operatører til at arbejde med dynamisk hukommelse ( ALLOCATE, DEALLOCATE, NULLIFY) er blevet introduceret.
  5. Tilføjede softwarekomponenter MODULE, PRIVATE, PUBLIC, CONTAINS, INTERFACE, USE, INTENT.
  6. Maskering af array-tildeling er indført (tildeling når en logisk betingelse pålagt array-elementer er opfyldt uden brug af betingede operatorer), samt arbejde med array-sektioner. En operatør og en konstruktion WHEREtil delvis udskiftning af cykler introduceres (højre side af opgaveoperatøren ændres ikke). Tildelingsmaskering gælder for næsten alle operatorer, konstruktioner og funktioner, der opererer på arrays.
  7. Standardoperationerne tildeling, addition, subtraktion og division og multiplikation med et tal udvides til arrays og deres sektioner defineret af sektioner. I dette tilfælde udføres element-for-element-tildeling.
  8. Der er nye indbyggede funktioner, primært til at arbejde med arrays. Funktioner til beregninger i matrixer: ALL(logisk produkt) og MASK(logisk addition), COUNT(antal sande elementer), PRODUCT(produkt af matrixelementer), SUM(addition af matrixelementer), DOT_PRODUCT(skalært produkt), MATMUL(matrixmultiplikation). Hjælpefunktioner er blevet tilføjet, såvel som funktionerne til at omforme og folde arrays.
  9. OOP -elementer dukkede op på sproget [14] . Introducerede afledte datatyper. En liste over forældede sprogfunktioner, der skal fjernes i fremtiden, er blevet annonceret separat.
  10. Yderligere funktioner til at arbejde med strengdata er blevet tilføjet, især funktionerne TRIM(fjern efterliggende mellemrum) og REPEAT(flere kopier af en streng) og venstre- og højrejusteringsfunktionerne.

Fortran 95 (1997)

ISO/IEC 1539-1:1997 [15] , en revision af den tidligere standard. Operatøren og konstruktionen introduceres FORALL, som tillader mere fleksibilitet end operatøren og konstruktionen WHERE, til at tildele arrays og erstatte besværlige sløjfer. FORALLgiver dig mulighed for at erstatte enhver tildeling af sektioner eller operatør og konstruktion WHERE, giver især adgang til diagonalen af ​​matrixen. Denne operatør anses for at være lovende i parallel databehandling, hvilket bidrager til mere effektiv parallelisering end sløjfer [16] [12] [17] .

Fortran 2003 (2004)

Vedtaget som ISO/IEC 1539-1:2004 [18] . Videreudvikling af OOP -støtte i sproget. Interaktion med operativsystemet. Følgende funktioner er også blevet tilføjet [8] :
  1. Asynkron data input-output.
  2. Midler til interaktion med C -sproget .
  3. Forbedring af dynamisk dataplacering [17] .

Fortran 2008 (2010)

ISO/IEC 1539-1:2010, det almindelige uformelle navn på Fortran 2008 [19] . Standarden forudsætter understøttelse ved hjælp af det parallelle computersprog (Co-Arrays Fortran) [8] [20] . Det er også planlagt at øge den maksimale dimension af arrays til 15, tilføje indbyggede specielle matematiske funktioner [8] osv.

Fortran 2018

Den seneste version af Fortran 2018-sproget (tidligere kendt som Fortran 2015) blev udgivet den 28. november 2018 [21] . Fortran 2018 (ISO/IEC 1539-1:2018) inkluderer: Samt understøttelse af ISO/IEC/IEEE 60559:2011 , hexadecimal input/output med flydende komma, IMPLICIT NONE-forbedringer og andre ændringer.

Egenskaber og karakteristika ved sproget

Fortran har et stort sæt indbyggede matematiske funktioner, understøtter arbejde med heltal, reelle og komplekse tal med dobbelt og høj præcision (det bruges til binære operationer real(10)), har et rigt værktøjssæt til at arbejde med arrays og eksterne filer. Modern Fortran (2003 og senere) har et komplet værktøjssæt til at arbejde med karakterdata.

Til at begynde med var sprogets udtryksmæssige midler ikke særlig store, da Fortran var det første sprog på højt niveau, der blev implementeret. Senere blev der tilføjet mange leksikalske konstruktioner til Fortran, som er karakteristiske for strukturel, modulær, generaliseret og objektorienteret programmering.

Kodenotationsformat

Strukturen af ​​programmerne var oprindeligt fokuseret på input fra hulkort og havde en række egenskaber, der var praktiske for dette særlige tilfælde. Så fra 1. til 5. kolonne var der et etiketområde, den 6. tjente til at markere teksten som en fortsættelse af den forrige linje (et hvilket som helst tegn undtagen et mellemrum og "0"), og fra 7. til 72. faktiske tekst blev lokaliseret operatør eller kommentar. Kolonne 73 til 80 kunne tjene til kortnummerering (for at genoprette et utilsigtet spredt dæk) eller til en kort kommentar, de blev ignoreret af oversætteren. Hvis operatørens tekst ikke passede ind i den tildelte plads (fra 7. til 72. kolonne), blev der placeret et fortsættelsestegn i 6. kolonne på næste linje, og derefter fortsatte operatøren på det. Det var umuligt at placere to eller flere operatører på en linje (kort). Da hulkort blev historie, blev disse fordele til alvorlige gener.

Derfor blev Fortran-standarden, der starter med Fortran 90, mens den fastholdte kildetekstens faste format blev tilføjet frit format , som ikke regulerer linjens position og giver dig mulighed for at skrive mere end én sætning pr. linje. Introduktionen af ​​frit format og moderne metoder til struktureret programmering [8] har gjort det muligt at skabe kode, hvis læsbarhed og klarhed ikke er ringere end kode oprettet ved hjælp af andre moderne programmeringssprog såsom Pascal , C eller Java . Moderne udviklingsmiljøer giver dig mulighed for at kombinere formater: Udvid for eksempel længden af ​​en streng til et frit format (normalt 132 tegn), giver dig mulighed for at skrive flere udsagn pr. linje, men giver dig samtidig også mulighed for at beholde venstre indrykning (lav en venstre margen), karakteristisk for det gamle faste format, efterlader den mest dedikerede kolonne for fejlmærker og formater, samt en linjefortsættelseskolonne.

En slags "telefonkort" af det gamle Fortran er et stort antal etiketter, der blev brugt i ubetingede spring GOTO-operatorer, loop-operatorer, betingede operatorer og format-input-outputbeskrivelsesoperatorer FORMAT. Det store antal etiketter og udsagn GOTOgjorde ofte Fortran-programmer svære at forstå.

Det er denne negative oplevelse, der er blevet årsagen til, at i en række moderne programmeringssprog (for eksempel i Java-sproget ) er etiketter og deres tilknyttede ubetingede springoperatorer blevet kraftigt ændret.

Imidlertid er moderne Fortran (hovedsagelig fra Fortran'90-versionen) befriet for et overskud af etiketter på grund af introduktionen af ​​operatorer som DO… END DO, DO WHILE, SELECT CASE, konstruktioner IF THEN- ELSEIF THEN- ELSE- END IF, osv. Desuden er det i moderne sprogstandarder kun de klassiske operatør GOTObrugt på mange sprog den dag i dag. Den beregnede operatør GOTO, såvel som ENTRY multiple-entry-to-procedures-konstruktionen, blev udeladt fra standarden, selvom de generelt stadig understøttes af compilere.

Hej Verden!

Fast format (mellemrum i linjeposition 1 til 6 er markeret med "␣"-tegn):

␣␣␣␣␣␣ UDSKRIV * , 'Hej, verden!' ␣␣␣␣␣␣ SLUT

Gratis format:

print * , "Hej, verden!" ende Bemærkninger.
  • Hovedprogrammets starterklæring PROGRAMer valgfri. Strengt taget er den eneste påkrævede erklæring i et Fortran-program END.
  • Valget af store eller små bogstaver til at skrive programerklæringer er vilkårligt. Med hensyn til moderne Fortran-sprogstandarder er mange store bogstaver og mange små bogstaver de samme.

Datatyper

Fortran understøtter 5 grundlæggende elementære indbyggede datatyper: ægte ( REAL) , kompleks ( COMPLEX) , heltal ( INTEGER) med eller uden fortegn, boolsk ( LOGICAL) og tegn ( CHARACTER) . Det er også muligt at oprette afledte datatyper ved hjælp af TYPE. Helt fra begyndelsen af ​​oprettelsen af ​​sproget var der 4 datatyper: ægte, kompleks, heltal og boolsk.

Der er en forestilling om en slags datatype eller typeparametre. Dette giver dig mulighed for at parametrere reelle og komplekse data (det vil sige at specificere præcisionen og rækkevidden af ​​decimalrækkefølgen) og andre data, hvilket øger applikationernes portabilitet.

For alle numeriske data er de sædvanlige aritmetiske operationer og tildelinger defineret, og der er indbyggede funktioner. En indbygget funktion kan kun tage et reelt eller komplekst tal ( ikke et heltal ) som argument .Log(x)x

For "enkelt" præcisions reelle tal tildeles som regel 4 bytes ( REAL(4)eller typevariationsparameter KIND=4), "dobbelt" - 8 bytes. For komplekse tal fordobles antallet af bytes.

Heltal kan tage fra 1 til 4 bytes. Moderne compilere gør det muligt for programmøren at arbejde med tal og "firedobbelt" præcision.

I aritmetiske operationer ændres typen som standard fra et heltal til et reelt tal og derefter et komplekst tal, eller ved at bruge en speciel indbygget numerisk funktion. Så de følgende udtryk er ækvivalente ( i  er et heltal): og . Log(i*1.)Log(real(i))

Strengdata (tegn) angives med en længde i parentes, enten efter typeattributten eller efter strengnavnet. For at angive en streng i programteksten bruges enkelte eller dobbelte anførselstegn. Så indtastningerne er ækvivalente: A='Det er varmt' eller A="Det er varmt" . Dette er nyttigt i tilfælde, hvor der er anførselstegn i selve strengen: B="Det er ikke varmt" .

For strenge er der en indbygget strengsammenkædningsoperation (addition): //. Der er 17 specialiserede indbyggede funktioner til karakterdata (udover de generiske, der håndterer alle typer data).

Etiketter  er heltal med ikke mere end 5 cifre; tegn er ikke tilladt. Etiketter bruges i sætninger GO TO, læse, skrive og formatere erklæringer samt fejl- og undtagelseshåndtering. Ud over etiketter har Fortran mulighed for at navngive kontrolstrukturer (loops, logiske forhold, strukturer FORALL... END FORALL, WHERE... END WHERE, SELECT CASE... END SELECT, TYPE... END TYPEosv.), og navnet på strukturen kan indeholde alle tegn tilladt i variabelnavne.

Indbyggede funktioner til tegndata

For tal-tegn konvertering : CHAR(i)og ACHAR(i). Konverter et heltal til dets tilsvarende operativsystemtegn eller ASCII -tabeltegn .

For tegn-tal konvertering : ICHAR(i)og IACHAR(i). Udfør omvendte transformationer.

Strengsammenligningsfunktioner : LGE(A,B), LGT(A,B), LLE(A,B)og LLT(A,B). Resultatet af funktionerne er "sandt", hvis strenglængderne ( L(A) og L(B) ), udtrykt i ASCII-tegn, opfylder henholdsvis følgende uligheder: L(A) L(B), L(A) L(B), L(A) L(B) og L(A) L(B) .

Længde funktioner : LEN(A)og LEN_TRIM(A). Den første returnerer længden af ​​strengen A (antal tegn), den anden returnerer længden af ​​strengen uden eventuelle mellemrum.

Konverteringsfunktioner : TRIM(A), ADJUSTL(A)og ADJUSTR(A), REPEAT(A,N). Funktionen TRIM(A)returnerer strengen A uden mellemrum. Funktionerne ADJUSTL(A)og ADJUSTR(A)justerer en streng (fjern mellemrum) til henholdsvis venstre og højre. Funktionen REPEAT(A,N)returnerer N kopier af streng A.

Linjesøgningsfunktioner: , , . Den valgfri parameter tilbage angiver søgeretningen: som standard venstre (for ) højre (for ). SCAN(A,B,[back])INDEX(A,B,[back])VERIFY(A,B,[back])back=.false.back=.true.

Funktionen SCANbestemmer positionsnummeret i streng A (venstre eller højre) for det først fundne tegn fra strenglisten B . Hvis resultatet er negativt, vil funktionen returnere et heltal 0. Funktionen INDEXbestemmer nummeret på den position, hvorfra den fulde forekomst af streng B i streng A begynder for første gang . Desuden kan søgningen udføres både til venstre og til højre, men positionsnummeret beregnes altid til venstre, fra begyndelsen af ​​linjen. Hvis søgningen mislykkes, returnerer funktionen 0. Funktionen er VERIFY omvendt til funktionen INDEX. Det VERIFYreturnerer således positionsnummeret for et sådant tegn i strengen A , som ikke er i maskestrengen B . Hvis alle (forskellige) tegn i streng A er til stede i maskestreng B, vil funktionen returnere 0.

Alle disse funktioner er elementære, og deres argument kan være en række tegn eller heltal. Resultatet vil være et matchet numerisk, tegn eller logisk array.

Fortran-standarder, der starter fra version 2003, giver mulighed for at arbejde med Unicode-tegn .

Ud over disse funktioner giver Fortran dig mulighed for at behandle symbolske data ved hjælp af dens indbyggede matrix (vektor) analyse , hvilket markant øger fleksibiliteten ved behandling af symbolske data.

I Fortran, for kompatibilitet med programmer skrevet på C-sproget, er der konceptet med en C-streng , som specificeres ved at tilføje et tegn efter citatet: A='This is a C-string'c . Null-strengen vil blive givet på denne måde: A='\0'c .

Underrutiner (procedurer og funktioner)

Underrutiner i Fortran har eksisteret siden den allerførste standard og er stadig et af de vigtigste programmeringsværktøjer [8] .

I Fortran sker opkald af underrutiner, funktioner og videregivelse af deres parametre udelukkende ved reference (og ikke ved værdi ). Derfor kan subrutinen ændre argumentet, der sendes til den i hovedprogrammet, hvis dette ikke specifikt forhindres. En sådan mekanisme gør det muligt at gøre notationen naturlig, når man skriver matematiske formler og samtidig opretholde høj ydeevne, når man arbejder med store dataarrays [24] .

Fortran-underrutiner kan indeholde på listen over parametre (kaldet formelle parametre) og valgfrie (valgfrie) parametre, eller de kan slet ikke indeholde nogen parametre.

Sprogstandarden gør det muligt at overbelaste procedurer og operationer via en generisk grænseflade, der kombinerer forskellige procedurer (hver opererer på f.eks. heltal, reelle, komplekse tal og tegnvariabler) under et enkelt (generisk) navn. I dette tilfælde er det nok at henvise til den generiske procedure i hovedprogrammet, og arten af ​​de udførte operationer vil afhænge af typen af ​​data, der tilbydes til proceduren til behandling. Alle indbyggede funktioner og subrutiner er lavet efter dette princip, f.eks COS(x). Overbelastning af procedurer, funktioner og operatører (desuden kan programmøren tilbyde sine egne symboler for overbelastede operatører, ud over de indbyggede) gælder ikke kun for indbyggede datatyper, men også for typer defineret af programmøren [12] .

Typer af underrutiner

Procedurer er opdelt i underrutiner og funktioner . Subrutiner er mere bekvemme, når du skal returnere et stort antal heterogene resultater; funktioner - når du returnerer et resultat af én type (inklusive et array).

Et underprogram er defineret af beskrivelsesoperatoren Subroutine underprogramnavn (liste over formelle argumenter) , en funktion er defineret af operatoren Function funktionsnavn (liste over formelle argumenter) .

En subrutine kaldes af sætningen Call subrutinenavn (liste over faktiske argumenter) . En funktion kaldes ved navn, med en liste over faktiske argumenter og uden brug af nogen speciel operator.

Fra og med F'90-standarden understøttes rekursive procedurer (ikke tilgængelig i tidligere versioner på grund af begrænset maskinhukommelse), som kræver en eksplicit specifikation for at deklarere recursive. I dette tilfælde skal resultatet af funktionen afvige fra navnet på selve funktionen.

Rene procedurer og funktioner ( pure subroutine [function]) er procedurer og funktioner introduceret af F'95-standarden, som ikke har bivirkninger. En ren funktion skal returnere en værdi og må ikke ændre nogen af ​​dens inputparametre og/eller globale data; en ren procedure bør kun ændre de parametre, der er eksplicit angivet som resultat (output) ved hjælp af attributten intent(outeller inout)). Muligheden for bivirkninger i Fortran (det vil sige i sidste ende muligheden for at ændre variabler i hovedprogrammet gennem en subrutine) er en bivirkning af den hurtige metode til at overføre til en adresse.

Rene programenheder kan ikke indeholde I/O-sætninger ( WRITEog READ) til eksterne filer og enheder, inklusive tastaturet og skærmen, samt programpause- og stopsætninger.

Alle indbyggede funktioner og underrutiner i Fortran, inklusive matematiske (undtagen dem, der har adgang til operativsystemet, dato- og klokkeslætsfunktioner og tilfældige talgeneratorer) er rene, det vil sige, at de ikke skaber bivirkninger. Rene funktioner blev introduceret for at forbedre programmeringskulturen og øge effektiviteten af ​​parallelisering af algoritmer [25] [9] .

Underprogramargumenter

Underprogramargumenter kan være alle indbyggede datatyper, inklusive arrays og deres sektioner, pointere og programmerdefinerede typer. Underrutineargumenter kan også være funktioner og andre underrutiner, bortset fra interne underrutiner, operatørfunktioner, generiske (generiske) procedurer (kun specifikke navne er tilladt) og nogle andre indbyggede typer.

Argumenter er opdelt i formelle og faktuelle . Argumenter er indesluttet i parentes efter underrutinenavnet og adskilt af kommaer. Navnene på de faktiske og formelle argumenter kan være de samme.

Formelle argumenter  er argumenterne for en underrutine (funktion), der er angivet i dens beskrivelse. Hvis subrutinen ikke har nogen argumenter, kan parenteserne udelades. Funktionen har parenteser, selvom der ikke er nogen formelle argumenter. En formel parameter-procedure kaldes en formel procedure .

Faktiske argumenter  er argumenter, der sendes til en underrutine eller funktion, der skal udføres, når den kaldes. En funktion uden argumenter kaldes med en tom liste i parentes, en underrutine uden parentes.

Formelle og faktiske argumenter skal være konsekvente . Typerne af argumenterne og varianterne af deres udseende skal være de samme, arrayet skal svare til en array (eller en sektion af en array) med samme konfiguration.

Der er arrays, der accepterer konfiguration og størrelse som formelle argumenter for procedurer. Et konfigurationstagende array  er et formelt array-argument, der arver konfigurationen af ​​dets tilsvarende faktiske array. For et sådant array, når det er deklareret, er dimensionen sat (sammenfaldende med dimensionen af ​​det faktiske array-argument), og de øvre grænser udelades. Som standard er de nedre grænser 1, men kan indstilles vilkårligt. Antallet og værdien af ​​elementerne i arrayet, der overtager konfigurationen, er nøjagtigt nedarvet fra det faktiske array-argument. Et array, der antager en størrelse  , er en tidligere, oprindelig Fortran'77-sprog måde at beskrive nedarvede arrays på, bibeholdt for kompatibilitet. For sådanne arrays er det kun den sidste dimension, der nedarves, hvis øvre grænse er beskrevet med en stjerne ( *). I dette tilfælde kan de formelle og faktiske arrays-argumenter have forskellige dimensioner. Arrays, der antager en konfiguration og størrelse, kan ikke være dynamiske eller være pointere. Procedurer, der arver arrays, skal have en eksplicit grænseflade.

Formelle argumentstrenge kan også arve (overtage) længden fra det tilsvarende faktiske strengargument. Strenge, der antager en længde , beskrives med symbolet *: Character (Len = *) streng_navn . Når man eksplicit angiver længden af ​​en streng, kan længden af ​​det strengformelle argument ikke være større end det tilsvarende faktiske streng-argument.

Argumenter er positionelle og centrale . Positionelle formelle og faktiske argumenter er knyttet til hinanden i den rækkefølge, de vises i argumentlisten, som skal matche. Nøgleord  - efter navnet på nøglen, som matcher navnet på det formelle argument. Nøgleord giver dig mulighed for at bryde rækkefølgen af ​​argumenterne eller springe nogle af dem over. Så for en underrutine med overskriften SubroutineONE (A, B, C, D), kan opkaldet være: CallONE (D= Z , C= Y , B= X , A= W ), hvor W, X, Y, Z  er de faktiske argumenter.

Nøgleargumenter giver dig mulighed for at have valgfrie argumenter , der kan udelades. I dette tilfælde skal de valgfrie argumenter have Optional. For eksempel, hvis Optional C, DCall er angivet, så kan ONE (B= X , A= W ) kaldes i dette tilfælde .

Procedurer med valgfri parametre skal have en eksplicit grænseflade.

Arbejde med arrays

Arrays er centrale i Fortrans filosofi. Alle sprogkonstruktioner, data, programenheder, operatører, indbyggede funktioner, loops er blevet skabt og er skabt til effektiv behandling, først og fremmest af arrays. Fortran, som det udvikler sig, følger princippet om at undgå den detaljerede (element-for-element) beskrivelse og bearbejdning af arrays så meget som muligt. Dette er især effektivt ved behandling af multidimensionelle arrays (den maksimale dimension af arrays i F2008-standarden er 15). Dette syn på arrays var ikke almindeligt for tidlige versioner af sproget; de første elementer i en generaliseret tilgang til arrays dukkede op i FORTRAN77; de udvikler sig stadig.

Arrays er enten statiske eller dynamiske . Dynamisk er opdelt i placeret og automatisk (dannes når en underrutine kaldes). Elementerne i et todimensionelt array i Fortran er arrangeret efter kolonner , ikke efter rækker, som for eksempel i C. Således ændres det første indeks i arrayet hurtigst. For effektivt at arbejde med arrays i indlejrede løkker bør du derfor indeksere de indre løkker med venstre indeks og de ydre løkker med højre. Som standard er arrays tildelt, input, output og initialisering kolonnevis.

gør k = 1 , 10 gør j = 1 , 20 gør i = 1 , 100 arr ( i , j , k ) = 25 ! højre brr ( k , j , i ) = 0 ! brugbart, men flere gange langsommere ende gøre ; ende gøre ; ende gøre

Arrays kan være af nul størrelse (inklusive hvis den nedre grænse overstiger den øvre). Array-grænseindekser kan være ethvert heltal. Standard nedre grænse er 1.

Ægte , allokerbar :: ArR (:,:,:) ! erklæring af et tildelt dynamisk reelt array Heltal , allokerbart :: ArI (:), ArSI ( 2 , 5 ) ! heltals dynamiske og statiske arrays Tegn ( 32 ), allokerbar :: ArC (:), ArC2 ( 20 ) ! en dynamisk række af strenge med en længde på 32 tegn og en statisk række af strenge Tildel ( ArR ( - 74 : 0 , 8 , 1 : 3 ), ArI ( 0 ), ArC ( 1 : - 1 )) ! placering af dynamiske arrays print * , størrelse ( ArR ), størrelse ( ArI ), størrelse ( ArC ), størrelse ( ArSI ) ! 1800 0 0 10 ArC2 ( 17 )( 5 : 27 ) = 'Dette er en strengtildeling' ! Linje nummer 17 vil blive skrevet ␣ ␣ ␣ ␣ Dette er ␣ tildelingen␣ af strengen␣ ␣ ␣ ␣ ␣ ... Sektioner af arrays, operatorer FORALLog WHERE

Fortran tillader effektiv tildeling af arrays uden sløjfer ved at maskere tildelingen ved hjælp af WHEREog operatorerne FORALL, samt array slicing og vektorindekser . I alle tilfælde evalueres den højre side af hele udtrykket indledningsvis (for alle array-indekser), og først derefter udføres tildelingen for indekser, der opfylder maske-arrayet. Beregninger ved hjælp af disse værktøjer giver dig mulighed for at øge ydeevnen og gøre det lettere for compileren at vælge sektioner af programmet, der kan udføres uafhængigt, det vil sige paralleliseres.

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-tildeling (indbygget overbelastning for tildelingsoperatør) arr1 = Sin ( arr ) + arr ! elementær sin funktion anvendes på hvert element i arrayet arr2 ( I1 : I2 : 1 , J1 : J2 : 2 , K2 : K1 : -4 ) = arr1 ( I1 : I2 : 1 , J1 : J2 : 2 , K2 : K1 : -4 ) ! _ _ elementtildeling i intervaller på 1, 2 og -4 (bagud) givet af en indekstriplet frr = ( / ( J , J = 1 , 100 ) / ) ! tildeling af et endimensionelt array via en cirkulær liste Forall ( i = I1 : I2 , j = J1 : J2 , k = K1 : K2 , arr ( i , j , k ) > 0. ) brr ( i , j , k ) = Log ( arr ( i , j , k ) )) ! udskiftning af cykler og betingelseserklæringer og konstruktioner. Tildelingsmaskering (maske — arr(i,j,k)>0.) Foralt ( i = 1 : N , j = 1 : N , k = 1 : N ) crr ( i , j , k ) = Sin ( 0,5 * ( i + j ) -k ) ! _ forlængelse af tværsnit For alt ( i = 1 : 100 ) ! For alle konstruktioner for flere tildelingssætninger drr ( i , i ) = 0. ! adgang til diagonalen af ​​matrixen err ( i , i , i ) = 1. ! og diagonaler af et tredimensionelt array End Forall

Mindre indlysende operationer er mulige:

Heltal V ( -2 : 2 , 1 : 5 ) _ V = omforme ( kilde = ( / ( i , i = 1 , 25 ) / ), form = ( / 5 , 5 / )) ! initialisering af et array med serienumre ved hjælp af array-konstruktøren og omformningsfunktionen print * , V ! Output til DOS-vinduet vil blive udført linje for linje ! 1 2 3 4 5 - 1. kolonne ! 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 ) ! Roter et stykke array print * , V ! Output til DOS-vinduet vil blive udført linje for linje ! 1 2 3 4 5 ! 6 7 8 9 10 ! 11 12 13 14 2 ændring i 3. kolonne 15 til 2 ! 16 17 18 19 3 ændring i 4. kolonne 20 til 3 ! 21 22 23 24 25

Operatørens og konstruktionens muligheder FORALLintroduceret af F'95-standarden er bredere end operatørens og konstruktionens WHERE, men sidstnævnte, i nogle tilfælde af logisk forgrening, giver dig mulighed for at forenkle koden på grund af tilstedeværelsen af ​​et alternativ ELSEWHERE, undgå indlejrede betingede operatorer og komplekse maskearrays.

Operatøren og konstruktionen FORALLtillader kun at bruge rene procedurer og funktioner . Ved maskering af tildelingen i operatorerne WHERE, FORALLsamt i specielle indbyggede funktioner til arrays (f.eks. SUM), beregnes den logiske array-maske før tildelingen og giver dig mulighed for at erstatte sløjfer med logiske forhold inde i dem, hvilket undgår ekstra arbejde til mikroprocessorgren -forudsigeren .

Et vektorindeks  er et heltals endimensionelt array, hvis værdier er indeksene for et andet array. Vektorindekser bruges til at skabe vilkårlige sektioner af multidimensionelle arrays og er deres generaliseringer. Når du bruger vektorindekser, skal du være opmærksom på gentagne indeksværdier på venstre side af tildelingsoperatøren, da der i dette tilfælde vil blive gjort et forsøg på at skrive muligvis forskellige værdier til en hukommelsescelle. Rækkefølgen af ​​indeksene er vilkårlig (selvom dette ikke bør overbruges for at undgå ydeevneforringelse).

Heltal vi ( 5 ) / 7 , 7 , 7 , 3 , 8 / , vj ( 4 ) / 1 , 2 , 3 , 10 / ! initialisering af arrays - vektorindekser Real arr ( 20 , 20 ), brr ( 10 , 10 ) brr = 0. ; arr = 1. ! vektorindekser kan også specificeres inde i det array, der bruger dem brr (( / 8 , 6 , 2 , 1 , 4 / ), vj ) = arr ( vi , vj ) ! dimensionerne af vektorindekser skal matche til venstre og højre, og deres værdier må ikke gå ud over grænserne for de arrays, der bruger dem ! størrelsen af ​​vektorindekser kan være mindre end størrelsen af ​​arbejdsarrays Indbyggede funktioner til arrays

Moderne Fortran har et stort antal specialiserede indbyggede funktioner til at arbejde med numeriske og tegnarrays (ud over de generelle metoder diskuteret ovenfor). Funktionernes argumenter er det numeriske og/eller tegn array array , den logiske array mask (som f.eks. er betingelsen array>0 ) og dimensionen dim af array array , som dannes (hvis dim argumentet er givet ) en sektion af arrayet langs en af ​​dimensionerne med tallet dim . Array- arrayet kan, medmindre andet er angivet, være heltal, indeholde reelle eller komplekse tal. Hvis maskearrayet ikke er angivet, anses dets værdi for at være identisk sandt. Den boolske maskemaske skal, hvis den er givet, have samme form som matrix eller en skalarværdi .TRUE..
Hovedparten af ​​funktionerne introduceret af F'90-standarden.

ALL(mask[, dim]) er en logisk funktion; returnerer "true", hvis alle elementer i den logiske array-maske er sande (langs den valgfri dimension dim ) og omvendt ellers.
ANY(mask[, dim]) er en logisk funktion; er sand, hvis mindst ét ​​element i den logiske maske er sand (langs den valgfri dimension dim ).
COUNT(mask[, dim]) er en heltalsfunktion; resultatet er lig med antallet af sande elementer i maskearrayet (langs den valgfri dimension dim ).

MAXLOC(array[, mask][, dim]), MINLOC(array[, mask][, dim]),
 er heltalsfunktioner, der returnerer henholdsvis indekset for maksimum- og minimumelementet (eller indekser for maksimum- og minimumelementerne) langs den valgfri dimensionsdim for elementer, der opfylder maskearrayet . Funktionerne returnerer indekset for det første element i array- arrayet . Hvis argumentet for dim funktion ikke er givet, eller hvis array  er en endimensional matrix, skrives resultatet til en endimensional matrix.
For flerdimensionelle arrays array skrives resultatet til et array med en rang, der er en mindre end rangeringen af ​​array- arrayet ( dim er udelukket ).

Indeksværdierne tælles i rækkefølge fra arrayets nedre grænser. Det vil sige, at hvis nummeret på den nedre grænse af array- arrayet er forskelligt fra én, så skal man for at få adgang til maksimum- eller minimumselementet i arrayet lægge MAXLOCforskellen MINLOCmellem indekset for den nedre grænse og en til resultatet af funktionerne. .

MAXVAL(array[, mask][, dim]), MINVAL(array[, mask][, dim]) — søgefunktioner for henholdsvis maksimum- og minimumselementet i array- arrayet for elementer, der opfylder den logiske mask-array- maske langs den valgfri dimension dim . Resultatet af funktionen er den samme type og variation som array . Array- arrayet kan kun være reelt eller heltal.
For en endimensional matrix , eller hvis der ikke er noget svagt argument , er resultatet en skalar, ellers en matrix med en rang, der er en mindre end rangeringen af ​​matrix .

FINDLOC(array, value[, dim][, mask]) er en heltalsfunktion, der returnerer indekset for matrixelementet lig med værdi . Introduceret af F2008-standarden. De søgte array-elementer opfylder den logiske mask array- maske langs den valgfri dimension dim . Typen af ​​værdiargumentet skal matche typen af ​​matrix og kan være en hvilken som helst indbygget type (inklusive kompleks, boolsk eller tegn). Funktionens resterende egenskaber ligner egenskaberne for funktionerne og . MAXLOCMINLOC

Fra og med F2003-standarden fungerer MAXLOCog -funktionerne MINLOC, ligesom funktionen FINDLOC, også på tegndata.

SUM(array[, mask][, dim])og PRODUCT(array[, mask][, dim])udføre henholdsvis summeringen og multiplikationen af ​​elementerne i arrayet. Betydningen af ​​funktionsargumenterne er SUMden PRODUCTsamme som for ovenstående funktioner.
Funktionen PRODUCTfungerer på komplekse data fra F2003-standarden.

DOT_PRODUCT(vector_1, vector_2)udfører et indre produkt i henhold til reglerne for lineær algebra af vektorer vektor_1 og vektor_2 (en-dimensionelle arrays) af samme størrelse. Endimensionelle arrays vector_1 og vector_2 kan indeholde data af enhver numerisk og boolesk type. Vektorerne vektor_1 og vektor_2 kan enten være numeriske eller begge booleske.

MATMUL(matrix_a, matrix_b) - Indbygget matrix multiplikationsfunktion. Multiplicerer to matricer, en matrix med en vektor, en vektor med en matrix i henhold til reglerne for lineær algebra. Funktionsargumenterne matrix_a og matrix_b er  todimensionelle eller endimensionelle numeriske (af enhver indbygget numerisk type) eller logiske arrays. Funktionsargumenter kan ikke være to vektorer på samme tid: Et af argumenterne skal være en matrix (todimensionelt array). Antallet af elementer i den første (eller eneste) dimension af matrix_b- arrayet skal være lig med antallet af elementer i den sidste dimension af matrix_a- arrayet . Introduceret af F'90 standarden.
I nogle tilfælde, når man beregner produktet af en kolonnevektor ved hjælp af en rækkevektor, hvilket kræver MATMULen yderligere transformation af vektorer til matricer af formen, (/m,1/)og når man bruger funktionen (/1,n/), er effektiviteten MATMULifølge Barteniev [12] mærkbart ringere end en konventionel indlejret løkke.
Ifølge NASA-tests [26] for produktet af matricer (to-dimensionelle arrays) overstiger ydeevnen MATMULaf ​​Intel-kompileren ved brug af den fulde optimering -O3 betydeligt (i nogle tilfælde med en størrelsesorden) ydeevnen af ​​indlejrede sløjfer , selvom for matricer med en størrelse på ~1000 × 1000 og større, er det noget ringere end ydeevneunderrutinerne DGEMM i LAPAK- biblioteket . På samme tid, for matricer ~100×100 og mindre , MATMULovergår den DGEMM med hensyn til hastighed. IBM Fortran-kompileren, der starter med version F'90, bruger MATMUL Winograd-Strassen-algoritmen med kompleksitet [27] til det . Bemærk, at de algoritmiske implementeringer af matematiske funktioner normalt ikke er specificeret af standarden og forbliver efter compilerudviklerens skøn.

MERGE(t_source, f_source, mask) — en funktion, der opretter et nyt array under kontrol af mask-array- masken fra elementerne i t_source og f_source arrays med samme form og størrelse som de originale arrays. Argument-arrays og resultat-array kan være af enhver indbygget type og matche i datatype, størrelse og form.
Hvis maskeelementet er sandt ( .ТRUE.), så er det tilsvarende element i resultatarrayet lig med det tilsvarende element i t_source- arrayet ; hvis falsk ( .FALSE.) - så til elementet i arrayet f_source .
Funktionsargumenter kan være skalarer; i dette tilfælde for eksempel MERGE(a,0,c>=0)=a· Θ(с) , hvor Θ(с)  er en heltal Heaviside-funktion .

MOVE_ALLOC(from, to) er en indbygget underrutine, der giver dig mulighed for dynamisk at omallokere et tidligere allokeret dynamisk array til med nye grænser og størrelse, som det dynamiske array fra . Dataene fra fra -arrayet kopieres til til -arrayet . Datatypen og rangeringen af ​​fra og til arrays skal matche. Efter at til -arrayet er omallokeret, frigives fra -arrayet og bliver ikke-allokeret. Det kan være nyttigt i numeriske metoder med varierende diskretisering af problemet ( multigrid og adaptive metoder).
Introduceret af F2003-standarden.

TRANSPOSE(matrix) er en funktion, der transponerer (bytte rækker og kolonner) en todimensionel matrix.

Moderne Fortran leverer indbyggede funktioner til at pakke og udpakke et multidimensionelt array til et en-dimensionelt array (henholdsvis fra et en-dimensionelt array) under kontrol af en logisk betingelse for at forbedre ydeevnen og spare hukommelse.

PACK(array, mask [, vector]) - funktion; pakker et multidimensionelt array af en hvilken som helst array -type i et endimensionelt vektorarray styret af den logiske array- maske . Den valgfri endimensionelle array- vektor skal være af samme datatype som array , og antallet af elementer i vector , hvis givet, skal være mindst lige så mange som antallet af sande elementer i mask . Hvis masken  er en skalar med værdi , skal antallet af elementer i .TRUE.vektorarrayet , hvis det er givet, være mindst lige så stort som det samlede antal elementer i matrixen .
Resultatet af funktionen vil være et endimensionelt array af samme type som array . Længden af ​​resultatet vil være lig med længden af ​​vektor , hvis en er givet; hvis ikke, så antallet af sande elementer i maske -arrayet . Hvis vektor ikke er angivet, og masken  er en skalar med værdien true , så er længden af ​​den resulterende endimensionelle vektor lig med antallet af elementer i array .
Det resulterende array er sekventielt udfyldt med array-elementer ( i den rækkefølge, de er placeret i computerens hukommelse), der opfylder de sande værdier af maske -arrayet . I dette tilfælde, hvis der er givet en vektor , vælges de manglende (muligvis) elementer i resultatarrayet fra det, og starter fra indekset efter det sidste sande element i array- arrayet i rækkefølge .
Så for en matrix vil resultatet af funktionen være en endimensionel matrix . Hvis der yderligere er angivet en vektor , vil resultatet være .
PACK(A, mask=A.NE.0)PACK(A, mask=A.NE.0, V)

Filer og I/O

Fortran har rige indbyggede værktøjer til input-output operationer, herunder til store dataarrays. Filer i Fortran er interne og eksterne.

En intern fil  er en hvilken som helst matrix, tegnstreng eller understreng. Interne filer er altid åbne som standard. En ekstern fil  er enhver fil, der er ekstern i forhold til det program, der udføres.

Begge filtyper bruger de samme skrive- WRITEog læseoperatorer READ. Interne filer bruges til tal-streng-tal-konverteringer og til at skabe blandede numeriske og tegnindtastninger.

Tegn ( 15 ) streng Real :: xyz =- 12 3.456 Heltal intg Skriv ( streng , * ) xyz ! Skriv nummer -123.456 til streng Udskriv * , 'string=' , streng ! streng=␣ -123.4560␣ ␣ Læs ( streng , '(I6)' ) intg ! Læsning af et heltal fra en streng Udskriv * , 'intg=' , intg ! intg=␣ -123 !...

Eksterne filer er underopdelt i formaterede (tekst-, CR- og LF-strømme), binære (binære), direkte visning af RAM og uformaterede (ikke-binære). Derudover kan de være direkte og sekventielle adgangsfiler med poster med fast og variabel længde (kun variabel for sekventielle filer) samt segmenterede poster (for meget store uformaterede sekventielle filer). Således giver Fortran dig mulighed for at oprette og behandle et ret stort antal filtyper - 15 måder at organisere på. Den maksimale størrelse af én post er 2,14 bytes.

Direkte adgangsfiler giver dig mulighed for at udføre I/O-operationer på poster med et givet nummer (uden at overskrive de højere eller lavere poster i filen).

Når du åbner en sekventiel fil, kan den placeres i begyndelsen, i slutningen (før du skriver "end of file"), hvilket giver dig mulighed for at tilføje data, efterhånden som de akkumuleres uden at overskrive tidligere indtastede, samt enten i begyndelsen eller i slutningen, afhængigt af den tidligere definerede filstatus (var den åben før eller ej).

Arbejde med hukommelse

I moderne sprogstandarder (startende med Fortran'90 eller Fortran'95) er det muligt at arbejde med tre typer dynamiske arrays (automatiske, allokerede og reference arrays), pointere , links ; der er indbyggede procedurer til at arbejde med hukommelse direkte og procedurer for bitvise operationer.

Sprogstandarderne forudsætter automatisk frigivelse af RAM optaget af enhver type dynamisk array efter afslutningen af ​​programmet eller subrutinen (procedure, funktion), selvom frigivelsen ikke blev udført eksplicit af programmøren. Dette giver dig mulighed for at undgå hukommelseslækager, når du arbejder med dynamiske arrays ved hjælp af Fortran (når du bruger pointere og i andre tilfælde er lækager mulige) med skødesløs programmering [12] .

Automatiske arrays (placeret af compileren) oprettes, når en subrutine kaldes og er dens lokale objekter. Deres grænser defineres hver gang proceduren påberåbes; på samme tid, når du forlader det, ødelægges de, og hukommelsen ryddes. Automatiske arrays er på stakken under afviklingen af ​​programmet , allokeret (ved hjælp af operatoren ALLOCATE) - på heapen [25] .

Fortran pointere ligner C pointere [12] , men når de løser beregningsproblemer og udvikler matematiske algoritmer, erstattes de i de fleste tilfælde med succes af andre Fortran-værktøjer.

Kontrolstrukturer

Startende med F'90-standarden adskiller den betingede grenkonstruktion sig IF THEN - ELSEIF THEN - END IFikke fra lignende konstruktioner på andre moderne sprog og erstattede den såkaldte. "aritmetik" IFmed etiketter, forældet [9] . Der er også en enklere form for den betingede operator: , hvor den eksekverbare operator skal være den eneste efter operatoren , for eksempel . IF(логическое условие) операторIFGoto метка

Valgkonstruktionen SELECT CASE - CASE - CASE DEFAULT - END SELECTadskiller sig tværtimod fra konstruktionen SWITCH - CASEi C-lignende sprog [28] , Java-sprog [29] [30] og ligner en del operatøren CASEi Pascal [31] med hensyn til dens muligheder .

Heltal N ( 74 ) ! vælg udtryk er et heltal, logisk, tegnudtryk eller ... ! heltalsarray eller tegnarray med et hvilket som helst antal elementer, der ikke er nul nameSC : Vælg Case ( N ( i )) ! nameSC — konstruktionsnavn, N(i) — array-element Case ( : -5 ) ! udføres for alle N(i) mindre end eller lig med -5 med et trin på +1 ! Blok 1 Sag ( -3 , -1 , 0 , 2 ) ! _ _ for variabel N(i) lig med -3, -1, 0, 2 ! Blok 2 Sag ( 50 : 100 ) ! for N(i) i området fra 50 til 100 inklusive (trin +1) ! Blok 3 Sag ( 400 ) ! for N(i)=400 ! Blok 4 Case ( 1 , 20 : 30 , 35 ) ! for N(i)=1, N(i) i området fra 20 til og med 30 og N(i)=35 ! Blok 5 Case standard ! til alle andre situationer. Case Default - valgfri, valgfri erklæring ! Standard blok Slut Vælg navnSC

Hvis værdien af ​​variablen N, kaldet selektionsudtrykket, matcher listen over vælgere (liste over værdier eller rækkevidde) i en hvilken som helst sætning CASE, for eksempel i den tredje for N=70 , så efter at have udført den tilsvarende blok af udsagn Block-3 , konstruktionsafgangene SELECT CASE[12] [25] og interrupt-sætninger (som BREAK) er ikke påkrævet . Operatøren CASE DEFAULTsåvel som navnet på konstruktionen er ikke nødvendig. Områder i vælgerlister for forskellige operatører CASEmå ikke overlappe eller have mindst ét ​​fælles element.

Valgudtrykket (N) kan være et element i et heltalsarray.

Områder i vælgerlister gælder kun for heltal eller tegn i stigende rækkefølge fra bunden til toppen; for tegn - i stigende rækkefølge efter deres koder .

I moderne Fortran er der to former for loops med en iterationstæller: den traditionelle konstruktion og DOden ENDDOmærkede loop. Sidstnævnte er blevet anerkendt som et forældet design siden F'90-standarden, men er stadig inkluderet i standarderne. For indlejrede løkker med mere indlejring kan den sidste form være mere kortfattet:

! Syntaks for den forældede sløjfekonstruktion gør 1 k = 1 , 10 ! 1 er slutningen af ​​løkken gør 1 j = 1 , 20 ! etiket kan være den samme for indlejrede løkker gør 1 i = 1 , 100 arr ( i , j , k ) = 25 1 Fortsæt ! etiketten kan kun vises foran enhver operatør L1 : gør k = 1 , 10 ! dog giver moderne notation dig mulighed for at navngive cyklusser, L2 : gør j = 1 , 20 ! hvilket er mere i tråd med begrebet struktureret programmering L3 : gør i = 1 , 100 ! og gør det nemmere at undgå fejl arr ( i , j , k ) = 25 slut til L3 slut til L2 slut til L1

Løkkehovedet med en tæller har følgende fulde form:

navn : DO I = N1 , N2 , dN ! konstruktionsnavn er valgfrit ... ! N1 er startværdien af ​​tælleren, N2 er slutværdien, dN er trinnet (løkkeparametre) END DO name ! Sløjfeparametrene er heltal af vilkårligt fortegn. dN er ikke-nul.

Antallet af udførelse af sløjfelegemet uden afbrydelse er Nc = ( max( int(N2 - N1 +dN)/dN), 0 ) og kan være lig med nul.

For eksempel vil loopet udføre nul gange, hvis N 2 <N 1 og skridtet er positivt: dN>0 . Hvis trinnet er negativt, dN<0, så vil cyklussen gå i omvendt rækkefølge, mens det for at fuldføre cyklussen er nødvendigt, at N 2 <N 1 . Hvis trinnet dN udelades, anses det som standard for at være lig med én: dN=1 .

Værdien af ​​sløjfevariablen I efter at have forladt den er altid lig N s +1 , det vil sige én mere end antallet af iterationer af sløjfen og ikke mindre end én: I≥1.

Det er også muligt at have en betinget loop  - , og en infinite loop  - , som har en standardform. DO WHILE(логическое условие)END DODOEND DO

Operatøren CYCLE имя циклаafbryder den aktuelle iteration af sløjfen og fortsætter til næste iteration af samme sløjfe. CYCLEHvis sløjfenavnet ikke er angivet, afbrydes iterationen af ​​den aktuelle sløjfe (hvori operatøren er placeret ).

Operatøren EXIT имя циклаafbryder udførelsen af ​​løkken med det angivne navn og overfører kontrol yderligere, og hvis der ikke er noget navn, afbryder den den aktuelle løkke (hvori operatøren er indlejret EXIT).

Operatørerne CYCLEog er EXITlogisk identiske med en operatør GOTO(under passende omstændigheder), men gør koden meget nemmere for programmøren at forstå og vedligeholde.

Kompilere

Siden den første udvikling af sproget er Fortran- kompilatorer blevet fremstillet af IBM. I øjeblikket sender IBM VS Fortran -optimeringskompileren [32] til IBM System z mainframes , hvis udviklingshistorie går tilbage til 1964, samt XL Fortran-kompileren [33] til platforme baseret på PowerPC -arkitekturen  - AIX , Linux og supercomputer Blue Gene (der var også en version til Mac OS X , da Macintosh-computere brugte PowerPC-processorer). Begge disse kompilatorer indeholder meget sofistikerede optimeringsprogrammer, resultatet af et halvt århundredes kontinuerlige videnskabelige arbejde udført af IBM-specialister. På basis af IBM Fortran XL-kompileren har Absoft, en IBM-forretningspartner, skabt og leverer Absoft Pro Fortran-kompileren til systemer baseret på PowerPC (Linux, Mac OS X) og Intel (Linux, Mac OS X, Windows) processorer [34] .

Indtil 1997 var Microsoft Corporation en stor producent af Fortran-kompileren til Windows-operativsystemet . Efterfølgende opgav hun deres udvikling på grund af lav rentabilitet. Herefter blev compileren leveret af DEC , som blev en del af Compaq i 1998 og sammen med sidstnævnte fusionerede med HP i 2002 . Denne version af compileren er videreudviklet af Intel , og compileren hedder Intel Fortran Compiler , som giver dig mulighed for at optimere kode til Intel IA-32, x86_64 og IA-64 platformene.

DEC leverer en compiler integreret i Digital Visual Fortran udviklingsmiljø baseret på Microsoft Visual Studio . De mest berømte produkter i denne linje er FPS 4.0 (Microsoft Fortran Power Station), DVF 5.0 og 6.0. Hver compiler kan understøtte flere Fortran-standarder. Fusionerne medførte, at efterfølgende produkter dukkede op på markedet under mærkerne Compaq og HP. HP sælger i øjeblikket et udviklingsmiljø version 6.6 til Intel/win32. Fortran-support er også implementeret for alle HP højtydende platforme.

En anden stor leverandør af Fortran udviklingssystemer er Lahey , som tilbyder integrerede løsninger til Windows og Linux.

I lang tid blev Watcom- kompileren betragtet som den bedste Fortran-kompiler til PC , som blev opdelt i et separat Open Watcom- projekt , som udvikler compileren på et åbent grundlag.

Blandt de gratis Fortran-kompilere bør man fremhæve compileren fra det tidligere Sun Microsystems (nu Oracle), som er en del af Sun Studio , som genererer effektiv kode under SPARC , x86 og x86-64 [35] og er tilgængelig til Solaris , OpenSolaris og GNU/Linux .

GNU Free Software Foundation udgav g77 Fortran 77-kompileren, som er open source og tilgængelig for næsten enhver platform og er fuldt ud kompatibel med GCC . Nu er den blevet erstattet af GFortran- kompileren , som implementerer næsten alle konstruktionerne af Fortran-95-standarden og mange af konstruktionerne i Fortran-2003-, Fortran-2008- og Fortran-2018-standarderne. Den er også fuldt bagudkompatibel med Fortran-77. Der er også et uafhængigt g95- projekt til at skabe en Fortran-95-kompiler baseret på GCC .

Interaktion med andre sprog

Mange programmeringssystemer giver dig mulighed for at forbinde objektfiler opnået som et resultat af oversættelse af et Fortran-program med objektfiler hentet fra compilere fra andre sprog, hvilket giver dig mulighed for at skabe mere fleksible og multifunktionelle applikationer. Et stort antal biblioteker er også tilgængelige for Fortran-sproget, der indeholder både rutiner til løsning af klassiske beregningsproblemer ( LAPACK , IMSL , BLAS ), opgaver til organisering af distribueret databehandling ( MPI , PVM ) og opgaver til opbygning af grafiske grænseflader ( Quickwin , FORTRAN ) / TK ) eller adgang til DBMS ( Oracle ).

Fortran i USSR

Fortran dukkede op i USSR senere end i Vesten, da Algol først i USSR blev betragtet som et mere lovende sprog . Kommunikationen mellem sovjetiske fysikere og deres kolleger fra CERN , hvor næsten alle beregninger i 1960'erne blev udført ved hjælp af Fortran-programmer, spillede en vigtig rolle i introduktionen af ​​Fortran [36] .

Den første sovjetiske Fortran- kompiler blev oprettet i 1967 til Minsk-2- maskinen , men den fik ikke meget berømmelse. Den udbredte introduktion af Fortran begyndte efter oprettelsen i 1968 af FORTRAN-DUBNA-kompileren til BESM-6- maskinen . Fortran er hovedsproget for ASVT- og SM-computere , ofte brugt sammen med RATFOR- forprocessoren . De ES-computere , der dukkede op i 1972 , havde allerede i første omgang en Fortran- oversætter ("lånt" fra IBM/360 sammen med anden software).

I 1970'erne udviklede IPM det grafiske bibliotek GRAFOR ("Graphic Extension of FORtran") [37] .

I slutningen af ​​1980'erne og begyndelsen af ​​1990'erne skabte fysikeren Andrei Zaretsky en række børnebøger, hvor en af ​​hovedpersonerne var professor Fortran , som forklarede det grundlæggende i computerfærdigheder og programmering til børn i et tilgængeligt sprog [38] [39] .

Noter

  1. ↑ 1 2 3 4 Historien om FORTRAN I, II og III - Journal of the ACM , 1981.
  2. ↑ V.E. Karpov. KLASSISK TEORI OM KOMPILERE. - Tutorial. 2. udgave - Moskva, 2011. - 91 s. - ISBN 5-230-16344-5.
  3. ↑ Plankalkül - sproget , som hævder at være håndfladen, blev opfundet tilbage i 1945, men blev først implementeret i 2000.
  4. ↑ Ordbog over fremmede ord. - M .: " Russisk sprog ", 1989. - 624 s. ISBN 5-200-00408-8
  5. ↑ Se for eksempel: Netlib Repository på UTK og ORNL Arkiveret 27. juli 2021 på Wayback Machine
  6. ↑ IMSL Fortran Numerical Library | Rogue bølge . Hentet 19. august 2015. Arkiveret fra originalen 16. august 2015.
  7. ↑ Barteniev O.V. 1-3 // Fortran for professionelle. ISML Matematisk Bibliotek. - Moskva: Dialog-MEPhI, 2001. - s1 - 448 s., s2 - 320 s., s3 - 368 s. - 3000 eksemplarer.  - 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 . Udvikling af programmeringssproget Fortran (1957—2007) og udsigter for dets udvikling // Computational methods and programmering, 2008, bind 9, s. 53-71 Arkiveret 2. april 2015 på Wayback Machine
  9. ↑ 1 2 3 Gorelik A.M. Del 2, kapitel 14-20 // Programmering i moderne Fortran. - Moskva: Finans og statistik, 2006. - 352 s. - 3000 eksemplarer.  — ISBN 5-279-03066-X .
  10. ↑ ANSI. X3.9-1966 - FORTRAN . — 1966. Arkiveret 1. november 2020 på Wayback Machine
  11. ↑ Fortran 77 - ANSI X3J3/90.4 arbejdsgruppe  . Hentet 18. februar 2021. Arkiveret fra originalen 11. november 2020.
  12. ↑ 1 2 3 4 5 6 7 8 Barteniev O.V. Moderne Fortran . - M . : Dialogue MEPhI, 2005. - ISBN 5-86404-113-0 . Arkiveret 10. februar 2011 på Wayback Machine
  13. ↑ Fortran 90 - Sidste arbejdsudkast  . wg5-fortran.org . Hentet 18. februar 2021. Arkiveret fra originalen 5. november 2020.
  14. ↑ A. M. Gorelik. Objektorienteret programmering i Modern Fortran Arkiveret 7. september 2011 på Wayback Machine
  15. ↑ Fortran 95 - Sidste arbejdsudkast  . wg5-fortran.org . Hentet 18. februar 2021. Arkiveret fra originalen 1. juli 2021.
  16. ↑ Gorelik A.M. 3. Introduktion til parallel programmering i Fortran // Programmering i moderne Fortran. - Moskva: Finans og 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 s. — ISBN 5-8243-0759-8 .
  18. ↑ Fortran 2003–Last Working Draft . Gnu.Org. Hentet 10. maj 2014. Arkiveret fra originalen 25. februar 2021.
  19. ↑ Fortran 2008 - Sidste arbejdsudkast . Gnu.Org. Hentet 10. maj 2014. Arkiveret fra originalen 3. marts 2021.
  20. ↑ Gorelik A. M. News Arkivkopi af 2. marts 2012 på Wayback Machine
  21. ↑ Fortran 2018 . ISO. Hentet 30. november 2018. Arkiveret fra originalen 1. december 2017.
  22. ↑ Yderligere interoperabilitet med C. ISO. Hentet 20. november 2017. Arkiveret fra originalen 8. marts 2021.
  23. ↑ Yderligere parallelle funktioner i Fortran . ISO. Hentet: 20. november 2017.
  24. ↑ Troy Douglas, Douglas A. Troy. om. fra engelsk. B.A. Kuzmina. Programmering i C til IBM PC = Komplet C-sprogprogrammering til IBM-PC / IV Emelin. - Moskva: "Radio og 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 moderne Fortran. - 1. - Moskva: Finans og statistik, 2006. - 352 s. — ISBN 5-279-03066-X .
  26. ↑ Thomas Clune. Sammenligning af Python, NumPy, Matlab, Fortran osv. . NASA Modeling Guru (2. nov. 2009 kl. 10.33). Hentet 7. oktober 2015. Arkiveret fra originalen 23. oktober 2015.
  27. ↑ Craig C. Douglas, Gordon Slishman. Varianter af matrix-matrix multiplikation for Fortran-90  // SIGNUM Newsl .. - 1994-04-01. - T. 29 , nej. 2 . — S. 4–6 . — ISSN 0163-5778 . - doi : 10.1145/181498.181500 . Arkiveret fra originalen den 9. august 2021.
  28. ↑ Switch-sætning (C++) . msdn.microsoft.com. Dato for adgang: 5. juni 2016. Arkiveret fra originalen 13. august 2016.
  29. ↑ Kontaktkonstruktionen . learn.javascript.ru. Hentet 5. juni 2016. Arkiveret fra originalen 9. juni 2016.
  30. ↑ Finesser af switch-sætningen . habrahabr.ru. Hentet 5. juni 2016. Arkiveret fra originalen 17. juni 2016.
  31. ↑ Sagsfremstillingen . www.freepascal.org. Hentet 5. juni 2016. Arkiveret fra originalen 22. maj 2016.
  32. ↑ VS FORTRAN . Hentet 8. marts 2010. Arkiveret fra originalen 9. august 2021.
  33. ↑ XL Fortran til Linux . Hentet 8. marts 2010. Arkiveret fra originalen 9. august 2021.
  34. ↑ Absoft Pro Fortran Compiler Suites Generel oversigt . Hentet 8. marts 2010. Arkiveret fra originalen 9. august 2021.
  35. ↑ Sun Studio - Benchmarks . Hentet 20. november 2007. Arkiveret fra originalen 26. oktober 2007.
  36. ↑ Essay af Alexander Rastorguev om Fortrans udseende i Dubna . Dato for adgang: 22. januar 2012. Arkiveret fra originalen 10. juli 2014.
  37. ↑ Historie om computergrafik i Rusland (utilgængeligt link) . Dato for adgang: 8. januar 2012. Arkiveret fra originalen 17. marts 2012. 
  38. ↑ Encyclopedia of Professor Fortran , Sutki.net  (29. januar 2008). Arkiveret fra originalen den 10. marts 2012. Hentet 11. juni 2013.
  39. ↑ Kirilenko, Alexander . Estland introducerer programmering i skoler fra folkeskolen , Noosphere  (7. september 2009). Arkiveret fra originalen den 9. september 2012. Hentet 11. juni 2013.

Litteratur

Links

  Gå til Wikidata-elementet  I sociale netværk
Tematiske steder
Ordbøger og encyklopædier
 Programmeringssprog