Ik werd gevraagd om te proberen mijn eerste bericht hier te schrijven, waarin wordt voorgesteld om C++ te gebruiken om te leren. Ja, er zijn veel exemplaren gebroken over dit onderwerp.

Ik begon, zoals waarschijnlijk de meeste schoolkinderen in de uitgestrektheid van ons uitgestrekte Moederland, de basisbeginselen te begrijpen via een blauw scherm, maar niet over de dood, maar over de dood. TurboPascal 7,0. Er was natuurlijk Basic, dat ik voor het eerst tegenkwam op de kleuterschool op de Sovjet Elektronika-computer. Toen leek het een vreemde teksteditor, want voor games was een computer door de ogen van een kind gemaakt. Maar al op het instituut maakte ik kennis met de Fortran-taal, nadat ik erover had geleerd, vraag ik me nog steeds af waarom het niet wordt gebruikt voor lesgeven.

Ja, velen zullen zeggen dat de taal dood is, niet overeenkomt met de moderne realiteit, en dat leerboeken met een titel zoals op de foto je alleen maar doen glimlachen. Ik zal proberen uit te leggen waarom deze taal zo geweldig is en waarom ik het als eerste taal aanbeveel. Als je geïnteresseerd bent, welkom bij cat.

Ik ben van mening dat de basis voor de basisprincipes van programmeren tijdens de schooljaren moet worden gelegd, in ieder geval op de middelbare school. Ook al wordt de computer in het leven alleen gebruikt voor het typen van tekst in Word of om in te communiceren in sociale netwerken, minimale kennis van wat een algoritme is en hoe een reeks acties moet worden gestructureerd om het gewenste resultaat te bereiken, zal de jongere op volwassen leeftijd in ieder geval niet schaden, maar zal hoogstwaarschijnlijk helpen een speciale mentaliteit te ontwikkelen.

Om ervoor te zorgen dat computerwetenschappenlessen een plezier zijn en geen nachtmerrie, moet de leerling begrijpen wat hij doet, hoe hij het doet en waarom het zo afloopt en niet anders. In essentie moet je immers informatie over de cyclus en de voorwaardelijke operator correct overbrengen, zodat iemand zelf programma's kan schrijven. Tegelijkertijd geldt: hoe eenvoudiger de syntaxis van de taal, hoe gemakkelijker het is om de logica van het schrijven van code te begrijpen. Als een persoon leert het juiste algoritme samen te stellen, hoeft hij voor het programmeren in andere talen alleen de syntaxis van deze taal te kennen en is de basis al gelegd.

Wat is er zo speciaal aan Fortran?

Laten we ons wenden tot de geschiedenis van de creatie van deze taal. Het verscheen in de verre jaren vijftig van de vorige eeuw, toen computers nog groot waren, er weinig programmeurs waren en informatica niet op school werd onderwezen en over het algemeen als een pseudowetenschap werd beschouwd. Wat nodig was, was een eenvoudige taal die ingenieurs en wetenschappers zou helpen formules die op papier zijn geschreven naar computers te 'voeden', zelfs via ponskaarten.

Vandaar de naam van de taal zelf: Voor mula Tran slator of “formulevertaler”. Die. Aanvankelijk was de taal gericht op mensen zonder speciale opleiding, waardoor het zo eenvoudig mogelijk moest zijn.

Welnu, de makers zijn erin geslaagd in eenvoud. Het klassieke eerste programma ziet er als volgt uit:

Programma hw write(*,*) "Hallo wereld!" einde
De syntaxis is zelfs iets eenvoudiger dan die van Pascal, het is niet nodig om " aan het einde van de regel te plaatsen ; " of " : " vóór het gelijkteken. Bovendien zullen mensen met minimale kennis van de Engelse taal geen moeite hebben om de betekenis van een eenvoudig programma te begrijpen.

Hier wil ik opmerken dat Fortran verschillende herzieningen van de standaarden heeft, waarvan de belangrijkste 77 en 90 zijn (met behoud van de continuïteit). 77 Fortran is echt archaïsch, er is een limiet aan de regellengte en het is noodzakelijk om het begin van de regel te laten inspringen, wat een cultuurschok kan veroorzaken voor een jonge kandidaat-programmeur. Het is niet voor niets dat programma's geschreven in Fortran 77 de beknopte naam "Brezjnev-code" uit de mond van mijn vriend kregen. Daarom verwijst al mijn tekst naar taalstandaard 90 en nieuwer.

Als voorbeeld zal ik een code geven voor het berekenen van de som van niet-negatieve gehele getallen van 1 tot n, ingevoerd via het toetsenbord, geschreven door mijn afgestudeerde student terwijl hij haar vanaf het begin les gaf in programmeren. Het was daar dat ik ervaarde dat ik Fortran als eerste taal leerde. Ik hoop dat dit gunstig voor haar was en dat mijn experiment een succes was. Ze leerde in ieder geval de basis in een paar lessen, waarvan de eerste een lezing over taal was.

Programmanummer impliciet geen! Variabelen geheel getal n,i,s ! Lichaam van chisla s=0 schrijf (*,*) "Enter n" lees (*,*) n if (n.le.0) schrijf dan (*,*) "Negatief of nul" anders doe i=1,n s =s+i end schrijf (*,*) "Sum=", s end if end
Het is gemakkelijk in te zien dat de manier waarop we denken de manier is waarop we code schrijven. Voor de student kunnen zich in principe geen moeilijkheden voordoen. De oplettende lezer zal zich natuurlijk afvragen wat impliciet is: geen en twee sterretjes tussen haakjes, gescheiden door komma's. impliciet niets vertelt ons dat we expliciet het type van de variabelen specificeren, terwijl zonder deze invoer de compiler het type zelf zal raden. Het eerste sterretje betekent dat invoer en uitvoer op het scherm plaatsvinden, en het tweede geeft aan dat het invoer- en uitvoerformaat automatisch wordt gedetecteerd. Eigenlijk ziet het Fortran-programma er niet ingewikkelder uit dan het hierboven geschreven stukje code.

Hoe zit het met de softwareomgeving?

Op scholen en bij alle overheidsinstanties rijst vaak de vraag over software, in het bijzonder over de licentieverlening ervan. Omdat er niet specifiek geld wordt toegewezen voor deze behoeften. In mijn tijd was dit tenminste een probleem, misschien is de situatie nu ten goede veranderd.

Programma's schrijven in Fortran Iedereen zal het doen teksteditor. Als u syntaxisaccentuering wilt, kunt u Notepad++ (ondersteunt alleen de standaard 77-syntaxis) of SublimeText gebruiken. We hebben het programma geschreven, hoe gaan we het compileren? Alles is hier eenvoudig, u kunt de gratis GNU Fotran gebruiken. Als u van plan bent het niet-commercieel te gebruiken, kunt u ook een compiler van Intel gebruiken, die goed is geoptimaliseerd voor gelijknamige processors en wordt geleverd met de minimaal vereiste IDE. Die. De instapdrempel is zeer preferentieel.

De beste ontwikkelomgeving voor Fortran blijft volgens veel gebruikers Compaq Visual Fortran 6.6, waarvan de nieuwste versie begin jaren 2000 werd uitgebracht. Waarom gebeurde het dat een omgeving gebaseerd was op Visuele studio 6.0, dat draait op maximaal Windows XP 32 bit zonder te dansen met een tamboerijn, en een limiet heeft op het gebruikte geheugen, is zo populair geworden onder Fortran-gebruikers. Het antwoord is weergegeven in de onderstaande figuur.

Dit is Compaq Array Visualizer, een zeer handig hulpmiddel voor het visualiseren van 1-, 2- en 3-dimensionale arrays tijdens het debuggen van programma's, rechtstreeks vanuit de debugger. Zoals ze zeggen, nadat ik het een keer heb geprobeerd, eet ik het nu. Feit is dat Fortran nu voornamelijk in de wetenschap wordt gebruikt (wat later zal worden besproken), in het bijzonder op het gebied waarmee ik te maken heb, namelijk in de atmosferische fysica. Bij het debuggen van programma's vertegenwoordigen arrays verschillende meteorologische velden, zoals temperatuur, druk en windsnelheid. Het vinden van een fout in grafische velden is veel gemakkelijker dan in een reeks cijfers, vooral omdat u meestal weet hoe het veld eruit moet zien, zodat duidelijke fouten onmiddellijk worden uitgesloten.

Helaas zijn alle ontwikkelingen op de compiler overgedragen van Compaq naar Intel. Intel ondersteunde aanvankelijk Array Visualizer, maar die versies waren al een bleke afspiegeling van het product van Compaq, het werken ermee was niet zo handig als voorheen, maar de functionaliteit bleef in ieder geval minimaal. Helaas stopte Intel met het ontwikkelen van nieuwe versies van Array Visualizer, waardoor hier een einde aan kwam het handigste hulpmiddel. Dat is de reden dat de meerderheid van de Fortran-gemeenschap programma's schrijft en debugt onder Compaq Visual Fortran op Windows, en gevechtsberekeningen uitvoert op Linux-servers met behulp van Intel-compilers. Intel, hoor alsjeblieft de smeekbeden van gebruikers, stuur een normaal hulpmiddel voor het visualiseren van arrays terug naar je debugger!

Fortran's plaats in de moderne wereld

En nu komen we bij het onderwerp dat gewoonlijk een verhitte discussie veroorzaakt met mijn collega's die Matlab gebruiken, die beweren dat de zeldzame taal die in dit bericht wordt beschreven nergens goed voor is. Hier ben ik het niet met hen eens. Feit is dat Fortran van oudsher werd gebruikt in technische of wetenschappelijke berekeningen, en daarom in de loop van de tijd veel kant-en-klare bibliotheken en programmacodes verwierf om een ​​bepaald probleem op te lossen.

De code wordt letterlijk van generatie op generatie doorgegeven en is bovendien goed gedocumenteerd. Je kunt er veel vinden kant-en-klare oplossingen vergelijkingen van de wiskundige natuurkunde, lineaire algebra (hier moet de succesvolle implementatie van het werken met matrices worden opgemerkt), integrale en differentiaalvergelijkingen en veel veel meer. Het is waarschijnlijk moeilijk om een ​​probleem op het gebied van de natuur- en wiskundige wetenschappen te vinden waarvoor een algoritme in Fortran niet zou worden geïmplementeerd. En als je rekening houdt met de uitstekende optimalisatie van Intel-compilers voor Intel-processors, ondersteuning voor parallel computing op krachtige clusters, dan wordt het duidelijk waarom deze taal een welverdiende eerste plaats inneemt in de wetenschappelijke gemeenschap. Ik denk dat je op elke supercomputer een Fortran-compiler kunt vinden.

De meeste serieuze modellen, althans op het gebied van de atmosferische fysica, zijn geschreven in Fortran. Ja, ja, de weersvoorspelling, waar iedereen van tijd tot tijd in geïnteresseerd is, wordt verkregen door berekeningen van modellen die in deze taal zijn geschreven. Bovendien staat de taal niet stil, maar verbetert hij voortdurend. Dus na de eerder beschreven standaarden 77 en 90 verschenen de nieuwe edities 95, 2003, 2008, waarvoor ondersteuning is geïntroduceerd in de huidige compilers. De nieuwste versies van Fortran hebben de oude, beproefde taal enigszins opgefrist en bieden ondersteuning voor de moderne stijl, door objectgeoriënteerd programmeren toe te voegen, waarvan de afwezigheid bijna de belangrijkste troef was van tegenstanders van deze taal. Bovendien heeft The Portland Group PGI CUDA Fortran Compiler uitgebracht, waarmee zeer parallelle berekeningen op videokaarten mogelijk zijn. De patiënt leeft dus meer dan alleen, wat betekent dat er nog steeds veel vraag is naar Fortran-programmeurs.

In plaats van een nawoord

En nu zou ik willen terugkeren naar het oorspronkelijk ter sprake gebrachte onderwerp over leren programmeren, en proberen de belangrijkste voordelen van Fortran kort te formuleren bij het kiezen van het als eerste taal.

• Fortran is heel gemakkelijk te leren, de syntaxis is begrijpelijk voor een ongetraind persoon. Als je eenmaal de basis kent, kun je gemakkelijk een andere taal opnieuw leren.
• Dankzij een gratis set tools ontvang je geen onnodige vragen van auteursrechthouders.
• De taal is bekend bij docenten, omdat deze al heel lang bestaat, en onze docenten zijn vooral vertegenwoordigers van de oudere generatie.
• Wijd verspreid over de hele wereld en is een schatkamer van allerlei soorten bibliotheken.
• Gestandaardiseerd, platformonafhankelijk en compatibel met eerdere revisies.
• Handig voor studenten van technische, en vooral natuurkunde- en wiskunde-majors, vanwege de focus op wetenschappelijke en technische berekeningen.
• Relevant en veelgevraagd tot op de dag van vandaag.

Dus waarom niet Fortran? * "PC Magic" 2000 nr. 6(28), blz. 49-50.

De eerste verscheen in 1955 algoritmische taal hoog niveau FORTRAN(FORmula TRANslator - formulevertaler). Het werd voornamelijk gebruikt om wetenschappelijke, technische en technische problemen op te lossen en werd ontwikkeld door IBM-medewerkers onder leiding van Johannes Backus. Even later, in 1957, installeerden John Backus en zijn medewerkers de eerste Fortran-compiler bij IBM (Bestinghouse). Programmeurs die voorheen uitsluitend in Assembly werkten, waren sceptisch over de mogelijkheden van een hoogwaardige taal van hoog niveau, dus het belangrijkste criterium bij het ontwikkelen van Fortran-standaarden en het maken van compilers op basis van deze taal was de efficiëntie van de uitvoerbare code. Overigens werd de term ‘compiler’ nog niet veel gebruikt, al was deze al geïntroduceerd door Grace Hopper, de enige vrouwelijke admiraal in de Verenigde Staten, die ook wel ‘de first lady van het programmeren en de grootmoeder van Cobol’ werd genoemd. ”
De meeste Fortran-instructies worden rechtstreeks vertaald in een of twee machine-instructies, eenvoudige syntactische constructies en actief gebruik labels en goto maakten het mogelijk om heel veel te krijgen snelle code, en als gevolg daarvan liepen Fortran-programma's soms sneller dan assembler-programma's. De interne structuur van het vertaalde programma zelf was ook heel eenvoudig: alle code, alle subroutines en alle gegevens, samen met een gemeenschappelijk blok, bevonden zich uitsluitend in statisch geheugen, waardoor het echter onmogelijk was om recursie te gebruiken.
Omdat Fortran de eerste taal op hoog niveau was die aan de behoeften van de meeste gebruikers van die tijd voldeed en bovendien gemakkelijk te leren was, verspreidde het zich zeer snel.
Vanwege het wijdverbreide gebruik van deze taal en de opkomst van veel Fortran-programma's (voornamelijk van computationele aard), is de kwestie van de standaardisatie ervan urgent geworden. In eerste instantie was het standaard Fortran IV In 1964 werd het, toen er nieuwe ideeën ontstonden, in 1978 aangenomen nieuwe standaard Fortran 77(f77) s een groot aantal modernere en flexibelere syntactische uitbreidingen. Tegenwoordig is de meest voorkomende variant van Fortran Fortran 90(f90) en Fortran 95. Een groep enthousiastelingen is bezig met het afronden van een superversie van de F2k-taal, die dit jaar zal verschijnen.
Hoewel nieuwe versies van de taal soms zowel onnodige toevoegingen (bijvoorbeeld uitbreidingen met betrekking tot dynamische geheugentoewijzing) als nuttige toevoegingen bevatten, zoals de modulaire organisatie van het programma, het werken met delen van arrays, enz., kan deze taal tegenwoordig niet veelbelovend worden genoemd. voor leren, omdat de syntaxis ervan aanzienlijk verouderd is.
Voor degenen die vaak verschillende rekenproblemen moeten oplossen, is het echter helemaal niet nodig om elke keer een wiskundeboek ter hand te nemen en ‘van nul af aan te beginnen’. In 90% van dergelijke gevallen is wat u zoekt al lang geïmplementeerd en gedebugd in Fortran. Daarom is het leven van Fortran hoogstwaarschijnlijk voor een lange tijd verzekerd.
Er is nog een andere, relatief jonge niche voor Fortran: parallel computergebruik, waar de strikte semantiek van de taal hoogwaardige programma's mogelijk maakt. Meestal wordt de f90-standaard gebruikt, enigszins uitgebreid met een set operatoren om delen van het programma aan te geven die geschikt zijn voor parallellisatie. Parallel Fortran heeft zijn eigen standaard HPF(Hoge prestaties Fortran). Niettemin voelden Fortran-fans, wier motto de legendarische zin was: "Waarom zou ik andere talen leren als ik alles in Fortran kan schrijven", de duidelijke ongeschiktheid ervan voor grootschalige projecten vanwege hun gehechtheid aan de syntaxis van de jaren vijftig, en probeerden om het modieuze OOP-ideeën te introduceren, maar Fortran is nooit als standaard naar voren gekomen.
Van de vrij verspreide versies van Fortran is f2c de bekendste, geïmplementeerd voor alle UNIX-systemen en die de tekst van een Fortran-programma omzet in C-code. Voor DOS is er een versie bcf77, die gratis wordt verspreid. Van de commerciële versies zijn de eerste die worden opgemerkt Microsoft Fortran, waarmee u dll-bibliotheken kunt maken, en Watcom Fortran, dat zeer efficiënte code genereert. Voor taken waarvoor hoge precisie computergebruik is een compiler van MicroWay ontworpen. Over het algemeen zijn Fortran-compilers van verschillende kwaliteit beschikbaar op absoluut alle computerplatforms.
De voornaamste verdienste van Fortran ligt echter elders. Toen de behoefte ontstond om een ​​zeer grote projecten zijn de tekortkomingen van Fortran, die voornamelijk verband houden met ‘zwaar’ debuggen, onnodig belastend geworden. Daarom diende Fortran als een sterke stimulans voor de ontwikkeling van de theorie van debugging- en testprogramma's. Er zijn honderden syntactische verificateurs voor Fortran-teksten verschenen, die verborgen logische fouten opsporen. Vervolgens groeiden theoretische programmeergebieden als gelijkwaardige optimalisatie van programmatransformaties, compilatie op hoog niveau, automatisch testen, enz. uit deze richting. Fortran mag je dus niet vergeten. Het heeft waarschijnlijk geen zin om het te gebruiken als hulpmiddel voor systeemintegratietaken, maar wat er is ontwikkeld de beste programmeurs over 30 tot 40 jaar zou dit het ontwikkelingsproces wel eens kunnen versnellen. In ieder geval zijn er nu onvergelijkbaar meer software-‘bouwstenen’ voor Fortran dan voor andere programmeertalen. ■

* * *
Johannes Backus geboren op 3 december 1924 in Philadelphia, Pennsylvania, in een rijke familie, bracht zijn jeugd door in Wilmington. Nadat hij in 1942 afstudeerde, ging hij naar de Universiteit van Virginia om scheikunde te studeren (op aandringen van zijn vader, een scheikundige), maar na enige tijd stopte hij met studeren en in 1943 werd hij opgeroepen om militaire dienst.
Backus begon te dienen in de luchtverdedigingsbrigade in Fort Stewart, Georgia, maar werd vervolgens naar de universiteit gestuurd om medicijnen te studeren.
Hij werkte enige tijd enthousiast in het stadsziekenhuis, maar in 1946 verloor hij zijn interesse in dit werk, verliet het leger en verhuisde naar New York, hoewel hij niet wist wat hij moest doen en hoe hij verder moest leven.
Na enige tijd ging Backus naar een opleidingsschool voor radiotechniek. "Ik had een heel goede leraar, en hij vroeg me om de kenmerken van sommige circuits te berekenen. Het was vreselijk vermoeiend, maar buitengewoon interessant."
Backus ging al snel naar Columbia University (New York) om wiskunde te studeren, waar hij een diploma behaalde hoger onderwijs(1949). Kort voordat hij afstudeerde, bezocht hij een computercentrum IBM aan Madison Avenue. En hier lachte het geluk hem voor de tweede keer toe - in 1950 werd Backus programmeur voor IBM.
De dominantie van IBM in de computerindustrie werd voor het eerst besproken in 1952. Het begon allemaal met de 701, ook wel bekend als de Defensiecalculator. Onmiddellijk na de release van Model 701 begonnen specialisten van de afdeling Toegepast Onderzoek het te verbeteren (1955-1956).

De meest serieuze veranderingen werden voorgesteld door John Backus, die later actief deelnam aan de creatie van de computer 704. Dankzij hem verscheen vooral de zogenaamde "speed-coding" -technologie, die het mogelijk maakte om aanzienlijk te vereenvoudigen het schrijven van programma's voor de 701. "De mogelijkheid van versnelde codegeneratie voor de 701, een computer met één adres en geen indexregisters, veranderde deze in een indexregistersysteem met drijvende komma, willekeurige adressering", Backus herinnerde zich: "Zodat gebruikers er niet langer mee hoefden te worstelen binaire code".
Zelfs toen verschenen de eerste componenten van de technologie voor het snel schrijven van programma's, die vandaag de dag worden gebruikt. Eigenlijk dit systeem werd de voorloper van soortgelijke complexen die in de jaren vijftig en zestig werden uitgebracht en vervolgens werden vervangen door talen op hoog niveau.
En in 1955 "vond" Backus Fortran uit, de eerste machinetaal hoog niveau. Vervolgens zal Backus, terugdenkend aan deze periode, zeggen: "We wisten niet waar we naar moesten streven, en wisten niet hoe we het moesten doen." Aanvankelijk was het de bedoeling dat al het werk begin 1954 voltooid zou zijn, maar de ontwikkeling van de taal was bijna twee jaar later voltooid.
De eerste versie van de compiler bestond uit 25.000 regels machinecode geschreven op magneetband. Elke IBM 704 werd voorzien van een kopie van het programma met een programmeerhandleiding van 51 pagina's.
In 1959 ontwikkelde Backus grammaticale regels om de syntaxis van talen op hoog niveau te beschrijven (Backus-Naur normale vorm, afgekort BNF).
In 1976 ontving John Backus de Nationale Medaille voor zijn bijdragen aan de wetenschap, en in 1991 stopte hij met werken in de informatica.

Vladimir Buslaev

OCR: eerste vst, 2016

Fortran(ook FORTRAN) dit programmeertaal, ontwikkeld in het begin van de jaren vijftig en nog steeds in gebruik. De naam is een afkorting voor "FORmula TRANslator". Vroege versies van de taal stonden bekend als FORTRAN, maar vanaf Fortran 90 werden de letters niet langer met hoofdletters geschreven. Officiële taalstandaarden noemen de taal nu "FORTRAN".

>Fortran wordt voornamelijk gebruikt voor wetenschappelijke berekeningen en numerieke analyses. Hoewel het oorspronkelijk een proceduretaal was, nieuwste versies Fortran heeft een aantal functies toegevoegd ter ondersteuning van objectgeoriënteerd programmeren voor beginners.

De eerste FORTRAN-compiler werd in 1954-57 voor de IBM 704 ontwikkeld door het IBM-team onder leiding van John W. Backus. Het was een optimaliserende compiler omdat de auteurs redeneerden dat niemand de taal zou gebruiken, zelfs niet bij het leren programmeren voor dummies, tenzij de prestaties vergelijkbaar waren met assembleertaal.

De taal raakte wijdverspreid onder wetenschappers en werd gebruikt om numeriek intensieve programma's te schrijven, wat de makers van Fortran-compilers dwong de compilercode nauwgezet te herschrijven om snellere code te genereren. Tegenwoordig zijn er veel leveranciers van krachtige Fortran-compilers. Veel vooruitgang in de compilertheorie en het ontwerp is ingegeven door de noodzaak om goede code voor Fortran-programma's te genereren, zoals vereist voor basisprogrammering.

Er zijn verschillende versies van de taal bekend, waaronder de beroemde FORTRAN IV (ook bekend als FORTRAN 66), Fortran 77 en Fortran 90. De laatste formele standaard voor de taal, gepubliceerd in 1997, staat bekend als Fortran 95. IBM's versies van de taal taal is nog nooit zo populair geweest, zoals ontwikkeld door andere bedrijven, en dit geldt vooral voor FORTRAN IV - WATFOR, de versie van FORTRAN IV ontwikkeld aan de Universiteit van Waterloo in Canada, was het populairst omdat het compilatiefoutmeldingen beter uitvoerde dan anderen. Hetzelfde geldt voor software voor automatische generatie blokdiagrammen van FORTRAN-programma's zijn buiten IBM ontwikkeld

Oorspronkelijk was de taal afhankelijk van nauwkeurige opmaak broncode en intensief gebruik van numerieke toestanden en de GOTO-instructie. Deze eigenaardigheden zijn verwijderd uit nieuwere versies van de taal. Latere versies introduceerden ook "moderne" programmeerconcepten zoals broncodecommentaar en tekstuitvoer, IF-THEN-ELSE-instructies (in FORTRAN 77), recursie (in Fortran 90) en parallel computing, terwijl werd geprobeerd het Fortran "lean" profiel te behouden. en hoge prestaties. Tot de meest populaire op Fortran gebaseerde talen behoren SAS, ontworpen voor het verkrijgen van statistische rapporten, en SIMSCRIPT, voor het modelleren van wachtrijprocessen.

Verkopers van hoogwaardige wetenschappelijke computers (Burroughs, CDC, Cray, IBM, Texas Instrumenten) heeft uitbreidingen aan Fortran toegevoegd om het gebruik van speciale hardwarefuncties mogelijk te maken, zoals: instructiecache, pijpverbindingsprocessor, vectorarrays, enz. Een van de IBM Fortran-compilers (H Extended IUP) bevatte bijvoorbeeld een optimalisatielaag die instructiesmachine dwong code houdt verschillende interne rekenblokken voortdurend bezig. Een ander voorbeeld is CFD, een speciale "variant" van Fortran die speciaal is ontwikkeld voor de ILLIAC IV-supercomputer die draait in het NASA Ames Research Center. Deze uitbreidingen zijn in de loop van de tijd verdwenen of deze elementen zijn opgenomen in de hoofdstandaard; De belangrijkste extensie is OpenMP, een platformonafhankelijke extensie voor gedeelde geheugentoegang. Een andere nieuwe extensie, CoArray Fortran, is ontworpen om te helpen ontwikkelen parallelle programmering En .

De eerste poging van een beginner om in Erlang te ontwikkelen kan erg frustrerend zijn, omdat de syntaxis van deze taal door veel programmeurs die zijn begonnen met studeren als geheim schrijven wordt beschouwd moderne talen. Het is moeilijk om een ​​lexicale analysator te schrijven als slechts één foutief teken kan resulteren in een runtimefout in plaats van een compilatiefout als de opgegeven constructies niet worden gebruikt. In sommige van de meest eerdere versies, waren er geen objecten (OOP) die als nuttige attributen voor het programmeren worden beschouwd moderne omstandigheden, of er was bijvoorbeeld geen dynamische geheugentoewijzing. Tegelijkertijd was de syntaxis van de Fortran-taal van toepassing op wetenschappelijk werk en berekeningen met getalsbewerkingen, en met veel van de tekortkomingen ervan werd in latere versies rekening gehouden. Fortran 95 heeft bijvoorbeeld zeer korte opdrachten om uit te voeren wiskundige bewerkingen met matrices en arrays, wat niet alleen de leesbaarheid van het programma aanzienlijk verbetert, maar ook nuttige informatie biedt voor de compiler, zodat deze bewerkingen kan vectoriseren. Om deze redenen wordt Fortran niet vaak gebruikt buiten de wetenschappelijke en technische computerwetenschappen; het blijft een taal voor hoge performantie numerieke berekeningen.

gfortran

• gfortran 4.5.0

Programmeertaal

Fortran is de eerste geïmplementeerde programmeertaal op hoog niveau (na ), maar met een klein voorbehoud: voor machines die zijn gebouwd volgens het klassieke von Neumann-schema. Gemaakt tussen 1954 en 1957 door een groep programmeurs onder leiding van John Backus bij IBM. Een paar jaar later begonnen de commerciële leveringen. Voordien werd het programmeren rechtstreeks in machinecodes of in symbolische assemblers uitgevoerd. De naam Fortran is een afkorting voor FORmula TRANslator, dat wil zeggen formulevertaler.

Fortran wordt veel gebruikt, voornamelijk voor wetenschappelijk en technisch computergebruik. Een van de voordelen van het moderne Fortran is een groot aantal van programma's en bibliotheken met subroutines die erop zijn geschreven. Onder wetenschappers is er bijvoorbeeld een gezegde dat elk wiskundig probleem al een oplossing heeft in Fortran, en inderdaad, je kunt tussen de duizenden Fortran-pakketten een pakket vinden voor matrixvermenigvuldiging, een pakket voor het oplossen van complexe integraalvergelijkingen, en nog veel meer. vele anderen. Een aantal van dergelijke pakketten zijn in de afgelopen decennia ontwikkeld en zijn nog steeds populair (vooral in de wetenschappelijke gemeenschap).

De meeste van deze bibliotheken zijn feitelijk eigendom van de mensheid: ze zijn beschikbaar in de broncode, goed gedocumenteerd, voorzien van foutopsporing en zeer effectief. Daarom is het duur om ze te veranderen, laat staan ​​te herschrijven in andere programmeertalen, ondanks het feit dat er regelmatig pogingen worden gedaan om FORTRAN-code automatisch om te zetten in moderne programmeertalen.

Een soort ‘visitekaartje’ van het oude Fortran is het enorme aantal labels dat werd gebruikt in zowel de onvoorwaardelijke sprongoperatoren GOTO, als in lusoperatoren, en in formaatinvoer/uitvoerbeschrijvingsoperatoren FORMAT. Het grote aantal labels en GOTO-verklaringen maakten Fortran-programma's vaak moeilijk te begrijpen.

Het was deze negatieve ervaring die de reden werd waarom in een aantal moderne programmeertalen (bijvoorbeeld Java) labels en bijbehorende onvoorwaardelijke sprongoperatoren volledig ontbreken.

Het moderne Fortran maakt echter een einde aan het teveel aan labels door operatoren te introduceren zoals DO ... END DO, DO WHILE, SELECT CASE. Tot de positieve kenmerken van het moderne Fortran behoren ook een groot aantal ingebouwde bewerkingen met arrays en flexibele ondersteuning voor arrays met ongebruikelijke indexering.

Interactie met andere talen

Bij veel programmeersystemen kunt u objectbestanden die zijn verkregen als resultaat van de vertaling van een Fortran-programma, koppelen aan objectbestanden die zijn verkregen van compilers uit andere talen, waardoor u flexibelere en veelzijdige toepassingen kunt creëren. Er is ook een groot aantal bibliotheken beschikbaar voor de Fortran-taal, die zowel routines bevatten voor het oplossen van klassieke computerproblemen (LAPACK, IMSL, BLAS), taken voor het organiseren van gedistribueerd computergebruik (MPI, pvm) als taken voor het construeren van grafische interfaces (Quickwin, FORTRAN /TK) of toegang krijgen tot DBMS (Oracle).

Fortran-erfenis

Fortran is al meer dan vijftig jaar in gebruik en een groot deel ervan is nog steeds in gebruik. Fortran is de primaire taal voor een aantal rekenintensieve problemen, zoals weer- en klimaatmodellering, vloeistofdynamica, computationele chemie, kwantumchromodynamica, het modelleren van de dynamiek van het zonnestelsel, het berekenen van de banen van kunstmatige satellieten en vele andere taken.

Draagbaarheid

In eerste instantie was portabiliteit voor Fortran een zeer urgente kwestie omdat er niet één standaard was referentie informatie van IBM. En computerbedrijven concurreerden met elkaar om de incompatibiliteit tussen verschillende compilers te garanderen. Het verschijnen van normen corrigeerde de zaak. De standaard uit 1966 legde de syntaxis en semantiek vast, maar leveranciers bleven incompatibele extensies introduceren. Zorgvuldige programmeurs realiseerden zich dat het gebruik van incompatibele extensies portabiliteitsproblemen zou veroorzaken en gebruikten vaak programma's zoals The PFORT Verifier om incompatibele extensies te identificeren.

Incompatibele extensies waren niet het enige probleem. Er waren een aantal problemen met numerieke berekeningen. Later werd het bijna universele idee van binaire drijvende-kommaberekeningen ontwikkeld en geïmplementeerd.

Toegang tot de uitvoerbare omgeving (bijv. opdrachtregel, omgevingsvariabelen) was behoorlijk moeilijk totdat dit in de standaard uit 2003 werd aangepakt.

Het is nu relatief eenvoudig om een ​​volledig draagbaar programma in Fortran te implementeren.

Syntaxiselementen:

Commentaar tot het einde van de regel	! of * in het eerste teken van de regel
Hoofdlettergevoelig	Nee
Variabele ID Reguliere expressie	[_a-zA-Z0-9](0-n)
Een waarde aan een variabele toekennen	=
Variabele declaratie	type::variabel
Een variabele declareren met waardetoewijzing	type::variabele = waarde
Expressies groeperen	()
Blok	doen... einde doen
Gelijkwaardigheid	= of.EQ.
Ongelijkheid	/= of.NE.
Vergelijking	== < > <= >= <>of.LT. .GT. .LE. .GE.
Een functie aanroepen	OPROEP f(a,b...)
Een functie aanroepen zonder parameters	BEL f
Vervolg	einde van de lijn
Als dan	if voorwaarde dan ... einde if
Als - dan - anders	if voorwaarde dan... anders... endif
Lus met postvoorwaarde	DOEN ... TERWIJL (voorwaarde)
For - volgende lus voor een bereik van gehele getallen verhoogd met 1	noem i = 1, 10
For - volgende lus voor een bereik van gehele getallen verlaagd met 1	noem i = 10, 1, -1

Voorbeelden:

Hallo Wereld!:

Voorbeeld voor versies Intel Visual Fortran 11.1, g95 0.93, gfortran 4.5.0

Dit voorbeeld is geschreven in een gratis formaat dat wordt ondersteund door Fortran 90 en daaropvolgende standaarden, evenals de .

Fortran commentaarprogramma in 90-stijl HelloWorld print * , "Hallo, wereld!" eindprogramma HelloWorld

Factoriaal:

Voorbeeld voor versies Intel Visual Fortran 11.1, g95 0.93, gfortran 4.5.0

Er wordt gebruik gemaakt van iteratieve bepaling van de faculteit en een vrij programmaformaat. De I- en A-formaatspecificaties worden gebruikt om respectievelijk decimale getallen en tekenreeksen uit te voeren. Bij het berekenen van faculteiten 13-16 treedt een rekenkundige overloop op, maar niet waardoor een fout ontstaat, dus de verkeerde waarden worden uitgevoerd:

13! = 1932053504
14! = 1278945280
15! = 2004310016
16! = 2004189184

programma Factoriaal geheel getal :: f , n f = 1 n = 0 do print "(I2, A, I10)" , n , "! = " , f n = n + 1 f = f * n if (n == 17 ) then exit end if end do end programma Factorial

Fibonacci-getallen:

Voorbeeld voor versies Intel Visual Fortran 11.1, g95 0.93, gfortran 4.5.0

Er wordt gebruik gemaakt van iteratieve bepaling van Fibonacci-getallen. Het moeilijkste in dit voorbeeld is het uitvoeren van de berekende waarden in in het gewenste formaat, op één regel en zonder extra spaties. De formaatspecificatie (I3, A, $) betekent dat het eerst een geheel getal in decimaal formaat afdrukt, precies drie tekens breed, vervolgens een tekenreeks afdrukt, en ten slotte $ de regelinvoer onderdrukt die standaard door de afdrukopdracht wordt gebruikt, zodat alles wordt afgedrukt op één lijn. Merk op dat de $-formaatspecificatie niet standaard is in het dialect; Het programma werkt, maar tijdens het compileren wordt hierover een waarschuwing weergegeven.

programma Fibonacci geheel getal :: f1 , f2 , f3 , i i = 1 f1 = 0 f2 = 1 do f3 = f2 + f1 f1 = f2 f2 = f3 i = i + 1 if (f1< 10 ) then print "(I1, A, $)" , f1 , ", " elseif (f1 < 100 ) then print "(I2, A, $)" , f1 , ", " else print "(I3, A, $)" , f1 , ", " end if if (i == 17 ) then exit end if end do print * , "..." end program Fibonacci

Kwadratische vergelijking:

Voorbeeld voor versies g95 0.93, gfortran 4.5.0

In het voorbeeld wordt het ingebouwde complexe gegevenstype gebruikt. // — operator voor het samenvoegen van tekenreeksen. Het getal vóór de haakjes in de formaatbeschrijving geeft aan hoe vaak het formaat tussen haakjes wordt herhaald (in in dit geval tweemaal - voor de eerste en tweede wortels).

programma Kwadratisch geheel getal :: a , b , c real :: d , p1 , p2 complex :: cp2 lees (* , * ), a if (a == 0 ) schrijf dan (* , * ) "Geen kwadratische vergelijking" stop einde indien gelezen (* , * ) b gelezen (* , * ) c d = b * b - 4 * a * c p1 = - b / 2.0 / a if (abs (d )< 1.0e-9 ) then write (* , "(A, F8.3)" ) "x = " , p1 elseif (d >0 ) dan p2 = sqrt (d ) / 2.0 / a write (* , "(2(A, F8.3))" ) "x1 = " , p1 + p2 , char (13 ) // char (10 ) / / "x2 = " , p1 - p2 anders cp2 = sqrt (cmplx (d )) / 2.0 / a write (* , "(2(A, F8.3, F8.3), A)" ) "x1 = ( " , p1 + cp2 , ")" // char (13 ) // char (10 ) // "x2 = (" , p1 - cp2 , ")" end if end

Hallo Wereld!:

Voorbeeld voor versies f2c 20090411, g95 0.93, gfortran 4.5.0

FORTRAN 77); de eerste zes tekens van elke regel zijn gereserveerd voor service-informatie - geeft aan dat de regel een commentaar of voortzetting is van de vorige, labels en regelnummers. Standaardset Fortran-tekens bevatten geen kleine letters, dus alle programma's worden in hoofdletters geschreven. De uitzondering op deze regel vormen tekenconstanten: deze kunnen alle tekens bevatten die door het systeem worden ondersteund.

De eerste regel geeft dit stukje code de naam HELLO en geeft aan dat dit het hoofdprogramma is. De programmanaam is onderworpen aan dezelfde regels als alle identificatienamen, d.w.z. moet beginnen met een letter en mag niet meer dan 6 tekens bevatten.

Het WRITE-commando implementeert het afdrukken. Een lijst met controleparameters die de uitvoer configureren, wordt tussen haakjes doorgegeven: UNIT selecteert het uitvoerbestand (standaard console), FMT selecteert het uitvoerformaat. Sterretjes geven standaardinstellingen aan. Het is niet nodig om parameternamen door te geven; kortom, hetzelfde commando zou er uitzien als WRITE (*, *) ....

In de meeste implementaties kan een stringconstante worden ingesloten zoals in enkele aanhalingstekens, en dubbel.

Een eenvoudige Hallo wereld! programma PROGRAMMA HELLO WRITE (UNIT =* , FMT =* ) "Hallo wereld!" EINDE

Factoriaal:

Voorbeeld voor versies f2c 20090411, g95 0.93, gfortran 4.5.0

Dit voorbeeld is geschreven in een vast formaat (FOTRAN 77-stijl) en maakt gebruik van iteratieve factoriële berekeningen.

Met Fortran kunt u variabele declaraties overslaan; in dit geval leidt het zelf de typen af, maar, in tegenstelling tot latere talen, niet op basis van de gebruikscontext van de variabele, maar op basis van de naam - als de eerste letter van de naam I..N is, wordt deze geselecteerd typ INTEGER, anders - ECHT. In dit geval zijn beide variabelen gehele getallen.

De DO-cyclus komt in dit geval overeen met For loop In latere talen loopt de lusteller N opeenvolgend door alle waarden van 0 tot 16. Het lichaam van de lus eindigt op de regel met het label 1, die wordt aangegeven in de luskop.

De opdracht PRINT gebruikt een standaarduitvoerformaat, dat varieert afhankelijk van de gebruikte compiler.

PROGRAMMA) C. Hierdoor moet, nadat de CC-regel met het resultaat teken voor teken is ingevuld, de rest van de regel handmatig met spaties worden gevuld.

Controleren of het volgende teken in de bronreeks een letter is, is te lang om op één regel te passen (alle tekens op de programmaregel vanaf de 73e positie worden genegeerd), dus moet deze in twee regels worden gesplitst en de tweede gemarkeerd als voortzetting van de eerste (door een willekeurig symbool op positie 6).

Vergelijkingsoperatoren in FORTRAN 77 worden geschreven als .LE. ,.GE. enz. vanwege het feit dat de > en< не входят в набор символов языка; они были добавлены только в Fortran 90.

PROGRAMMA CAMELC TEKEN TEKST * 30 , CC * 30 LOGISCHE LSPACE LEZEN (* , "(A)" TEKST NCC = 0 LSPACE = .TRUE. DO 1 , I = 1 , LEN (TEKST ) NC = ICHAR (TEKST (I : I )) IF (NC .GE. 65 .AND. NC .LE. 90 .OR. > NC .GE. 97 .AND. NC .LE. 122 ) THEN ALS (LSPACE ) THEN ALS (NC .GE. 97 .EN. NC .LE. 122 ) THEN NC = NC - 32 EINDE ALS ANDERS ALS (NC .GE. 65 .AND. NC .LE. 90 ) THEN NC = NC + 32 END IF END IF NCC = NCC + 1 CC (NCC : NCC ) = CHAR (NC ) LSPACE = .FALSE. ELSE LSPACE = .TRUE. EINDE ALS 1 DOORGAAT DOEN 2, I = NCC + 1, LEN (CC) 2 CC (I: I) = "" SCHRIJF (*, *) CC EINDE

De programmeertaal Fortran wordt voornamelijk gebruikt voor wetenschappelijk computergebruik. Uitgevonden in 1954, het oudste taal programmeren op hoog niveau, gevolgd door Lisp (1958), Algol (1958) en COBOL (1959). Het aantal wetenschappelijke bibliotheken geschreven in Fortran en de creatie van speciale vertaler-compilers zorgen ervoor dat de taal vandaag de dag kan worden gebruikt. Bovendien zijn er meerdere rekenmachines gemaakt voor vectorisatie, coprocessors en parallellisme, die deze taal doorkruisen voor gebruik in industriële productie moderne wereld.

John Backus, een IBM-radio-ingenieur, publiceerde in 1954 artikelen met de titel "Preliminary Report", "Specifications for the IBM Matmal Transmula TRANslating System", waaruit de term FORTRAN voortkwam. Daarna kostte het nog eens twee jaar inspanning van het hele team, dat hij leidde, om de eerste compiler voor de programmeertaal Fortran te schrijven (25.000 regels voor de IBM 704).

De naam van de taal werd oorspronkelijk geschreven in hoofdletters FORTRAN en werd gebruikt om te verwijzen naar taalversies tot Fortran 77, in tegenstelling tot gratis versies syntaxis sinds Fortran 90. In de Fortran 77-standaard maken kleine letters geen deel uit van de taal, maar de meeste compilers ondersteunen ze naast de standaard.

Tegenwoordig is de programmeertaal Fortran de dominante programmeertaal die wordt gebruikt technische toepassingen. Daarom is het belangrijk dat afgestudeerde ingenieurs Fortran-code kunnen lezen en wijzigen. Van tijd tot tijd voorspellen zogenaamde experts dat de taal zijn populariteit zal verliezen en binnenkort helemaal niet meer zal worden gebruikt.

Deze voorspellingen zijn altijd mislukt. Fortran is de meest duurzame computerprogrammeertaal in de geschiedenis. Een van de belangrijkste redenen waarom de programmeertaal Fortran heeft overleefd en zal overleven, is traagheid software. Nadat het bedrijf veel middelen en mogelijk miljoenen dollars heeft uitgegeven software, is het onwaarschijnlijk dat ze de software in een andere taal zal vertalen.

Het grote voordeel van Fortran is dat het gestandaardiseerd is door de internationale instanties ANSI en ISO. Als een programma dus in ANSI is geschreven, kan het op elke computer met een Fortran 77-compiler worden uitgevoerd. belangrijke gegevens. Fortran objectgeoriënteerde programmeertaalprogramma's bestaan ​​dus op verschillende softwareapparaten.

Stadia van het creëren van een taalplatform:

1. In 1954-1957 werd de eerste compiler helemaal opnieuw ontwikkeld. In die tijd waren er geen “high level talen” (=HLL), de meeste besturingssystemen waren eenvoudig en het geheugen was klein, ongeveer 16 Kb. De eerste compiler draaide op de IBM 704. Deze HLL-taal was veel efficiënter dan assembleren en erg populair in zijn tijd.
2. FORTRAN II verscheen in 1958. Datzelfde jaar werd FORTRAN III ontwikkeld, maar nooit op grote schaal geproduceerd.
3. In 1961 werd FORTRAN IV opgericht. Het bevatte verbeteringen zoals de implementatie van de COMMON- en EQUIVALENCE-verklaringen.
4. In 1962 begon een ASA-commissie met de ontwikkeling van een standaard voor de objectgeoriënteerde programmeertaal Fortran. Hierdoor kon de verkoper het op elke nieuwe computer gebruiken. En dit feit maakte het nog populairder. HLL, de taal werd beschikbaar in Apple-systemen en TRS80.
5. In 1967 werd FORTRAN 66, 's werelds eerste HLL-standaard, uitgebracht. Door de publicatie van de standaard werd de taal op grotere schaal geïmplementeerd dan welke andere taal dan ook. Halverwege de jaren zeventig was vrijwel elke computer, mini of mainframe uitgerust met de standaardtaal FORTRAN 66. De taal gebruikte if-statements, goto-statements en spagethi-programma's. Dit soort gestructureerde programmering werd populair in de jaren 60 en 70.
6. "Fortran" bestond vooral op ponskaarten, waarbij het FMS-systeem de lay-out van de bronnen optimaliseerde totdat Fortran 90 een "vrije" syntaxis introduceerde. Daarin begint de Fortran-arraycode vanaf de 7e kolom en mag niet langer zijn dan 72 duizend tekens.

Er moet ook worden opgemerkt dat vóór Fortran 90 spaties geen betekenis hadden tussen de 7e en 72e kolom. Zo kan de cyclus "DO I = 1,5" ook geschreven worden als "DOI = 1,5". Aan de andere kant is "DO I = 1,5" gelijk aan "DOI = 1,5".

Er zijn talloze industriële codes geschreven in Nastran, NAG en de IMSL-Fortran-bibliotheek. Compatibiliteit van nieuwe versies met eerdere versies is belangrijk. Om deze reden is Fortran 90 volledig compatibel met Fortran 77. Volgende versies van de standaard hebben echter al incompatibiliteiten geïntroduceerd.

Al snel volgden de meer geavanceerde talen Fortran 90 en Fortran 95, bijgewerkt naar de huidige Fortran-2003-standaard. Ondanks het feit dat moderne compilers onbeperkt werken in alle huidige versies van Windows en zelfs 64-bits processors ondersteunen. Fabrikanten hebben inmiddels de trend van de tijd onderkend en bieden compilers voor Linux aan in de vorm van de objectgeoriënteerde programmeertaal Actor Fortran.

Vereisten voor het gebruik van een programmeertaal

Het moet duidelijk zijn dat Fortran nog steeds een veelgebruikte programmeertaal is en vooral wordt gebruikt op het gebied van ontdekking. Klassieke toepassingen, bijvoorbeeld in de natuurkunde of techniek, waar uitgebreide en complexe wiskundige berekeningen worden uitgevoerd. Ze zijn erg handig vanwege de uitgebreide wiskundige bibliotheken die voor verschillende compilers bestaan. Samenvattend wordt Fortran vandaag de dag nog steeds gebruikt om een ​​aantal redenen:

• De beschikbaarheid van talrijke functionele bibliotheken is gedurende vele jaren ontwikkeld.
• Beschikbaarheid van software in Fortran, waarvoor zeer belangrijke middelen nodig zijn voor ontwikkeling, wanneer het overstappen naar een andere taal als te duur wordt beschouwd.
• Beschikbaarheid van krachtige compilers met ingebouwde Fortran-functies, die zeer snelle uitvoerbare bestanden produceren.
• De taal is toegankelijker voor een uitvinder die geen gespecialiseerde computercursus heeft gevolgd.

Veel wetenschappelijke programma's zijn nu geschreven in C en C++, waarvoor op de meeste machines compilers beschikbaar zijn. Andere gecompileerde talen worden soms gebruikt voor wetenschappelijk computergebruik, en vooral voor programma's zoals Scilab of Matlab. Deze laatste omvatten ook de BLAS- en LAPACK-bibliotheken, ontwikkeld in Fortran-programmering. Matlab was oorspronkelijk een Fortran-programma dat werd verspreid onder universiteiten en onderzoekscentra.

Hoewel Tom Lahey nu de "enige" algemene compiler is, wordt Lahey Computer Systems nog steeds door veel programmeurs gebruikt. Lahey werkt al een aantal jaren samen met Fujitsu, waarbij Lahey zich concentreert op de Fortran-parser en Fujitsu op de codegenerator. De huidige Compiler Suite voor Windows heet Lahey Fujitsu Fortran 95 (LF95) en is beschikbaar in verschillende versies, waarvan sommige ook integreren met Visual Studio .NET 2003.

Er is ook een goedkope versie van LF95 Express zonder eigen IDE. De huidige versie is 7.1. op Linux wordt aangeroepen door de Lahey/Fujitsu Fortran 95 v6.2-compiler voor Linux en is beschikbaar in twee verschillende versies. De Pro-versie bevat bijvoorbeeld OpenMP v2.0-compatibiliteit, een eenvoudige Winteracter Starter Kit grafische engine, wiskunde bibliotheek en de wetenschappelijke bibliotheek met Fujitsu 2-routines.

Een andere fabrikant is Absoft. Compilers en C++ bestaan ​​niet alleen voor Windows en Linux, maar ook voor OS X op de Macintosh. Deze compilers zijn interessant voor ontwikkelaars die alle drie de platforms moeten of willen ondersteunen. Helaas maakt Absoft onderscheid tussen 32-bits en 64-bits versies voor Linux, waarbij momenteel versie 10.0 van Fortran 95 voor 64-bits Linux wordt gebruikt.

Relatief nieuw op de markt is de EKOPath Compiler Suite. Deze bestaat uit C++-compilers en een Fortran-ontwikkelomgeving voor Linux, die ook afzonderlijk verkrijgbaar zijn en vooral gericht zijn op 64-bit AMD-gebruikers. Het draait ook op Intel EM64T. Microsoft probeerde ook ooit een "goedkope markt" voor Fortran te vinden en introduceerde de Microsoft Powerstation op de markt.

De markt was misschien te klein voor de softwaregigant, maar Digital nam in 1997 een deel van de code over en gebruikte zijn ervaring met de Digital Unix- en OpenVMS-compilers. Dit was de geboorte van het nog steeds zeer succesvolle Digital Visual Fortran. Op een gegeven moment verhuisde Digital vervolgens naar Compaq, de compiler werd ontwikkeld naar de huidige versie van Compaq Visual Fortran (CVF) v6.6.

Naast de "normale" 32-bit platforms zijn er verschillende 64-bit compilers, bijvoorbeeld voor Intel Itanium en Intel EM64T. Hoewel ze niet "dringend" zijn vanwege de omvang van het aanbod, zijn ze wel beschikbaar gratis download via websysteem Intel-ondersteuning Premier.

Na een eenmalige, wat omslachtige registratie, kun je er een jaar lang gebruik van maken, met elke paar weken nieuwe updates. Zelfs oudere versies blijven beschikbaar.

Een Fortran-programma is een reeks tekstregels. De tekst moet een specifieke syntaxis volgen. Bijvoorbeeld: een cirkel met straal r, oppervlakte c.

Dit programma leest de werkelijke straal en bepaalt de oppervlakte van een cirkel met straal r:

"Straal r:"lees (*), *) r;

oppervlakte = 3,14159 * r * r;

schrijf (*) (*, *) "Gebied =";

Regels die beginnen met "C" zijn commentaar en hebben geen ander doel dan het programma leesbaarder te maken voor mensen. Aanvankelijk werden alle Fortran-programma's in hoofdletters geschreven. De meeste programmeurs schrijven nu kleine letters omdat dit beter leesbaar is.

Een Fortran-programma bestaat doorgaans uit een hoofdprogramma of stuurprogramma en verschillende subroutines, procedures of subroutines. Hoofdprogrammastructuur:

• de naam van het programma;
• verklaringen;
• verklaringen;
• stop;
• einde.

Cursief moet niet worden opgevat als letterlijke tekst, maar eerder als een algemene beschrijving. De stop-instructie is optioneel en lijkt misschien overbodig, omdat het programma toch stopt als het het einde bereikt, maar het wordt aanbevolen om een ​​programma altijd te beëindigen met een stop-instructie om te benadrukken dat de uitvoeringsstroom wordt beëindigd.

Regels voor kolompositie

Fortran 77 is geen vrije formaattaal, maar heeft een zeer strikte set regels voor het formatteren van de broncode. De belangrijkste regels zijn de regels voor de kolomindeling:

• Kol. 1: Blanco of “c” of “*” voor opmerkingen.
• Kol. 2-5: operatormarkering.
• Kol. 6: voortzetting van de vorige regel.
• Kol. 7-72: verklaring.
• Kol. 73- 80: Volgnummer.

Een Fortran-regel die begint met de letter "c" of een asterisk in de eerste kolom is commentaar. Opmerkingen kunnen overal in een programma verschijnen. Goed geschreven zijn ze van cruciaal belang voor de leesbaarheid van een programma. Commerciële Fortran-codes bevatten vaak ongeveer 50% commentaar. Het kan ook zijn dat u programma's tegenkomt die een uitroepteken (!) gebruiken. Dit is zeer afwijkend in Fortran 77, maar is toegestaan ​​in Fortran 90.

Het uitroepteken kan overal op een regel verschijnen. Soms past een uitspraak niet op één regel, dan kun je de uitspraak opdelen in twee of meer regels en op de juiste plek een vervolgteken gebruiken.

1. C23456789 - Dit demonstreert de positie van de kolom.
2. "C" - de volgende operator passeert twee gebieden met fysieke lijnen.
3. Oppervlakte = 3,14159265358979+ * r * r.

Lege spaties worden genegeerd vanaf Fortran 77. Als u dus alle spaties in Fortran 77 verwijdert, is het programma syntactisch nog steeds correct, hoewel het bijna onleesbaar is voor de operators.

Variabelenamen in Fortran bestaan ​​uit 1-6 tekens, waaruit u kunt kiezen letters a-z en nummers 0-9. Het eerste teken moet een letter zijn. Fortran 90 staat variabelenamen van willekeurige lengte toe. Fortran 77 maakt geen onderscheid tussen hoofdletters en kleine letters; het gaat er zelfs van uit dat alle invoer hoofdletters is. Bijna alle F 77-compilers accepteren echter kleine letters. Elke variabele moet in een declaratie worden gedefinieerd. Hiermee wordt het type van de variabele ingesteld. De meest voorkomende variabelenlijsten zijn:

• geheel getal;
• echt;
• dubbele precisie;
• complex;
• logisch;
• karakter.

De lijst met variabelen moet bestaan ​​uit namen, gescheiden door komma's. Elke variabele moet precies één keer worden gedeclareerd. Als een variabele niet wordt gedeclareerd, gebruikt F 77 een reeks impliciete regels om het type vast te stellen. Dit betekent dat alle variabelen die beginnen met de letters "in" gehele getallen zijn, en alle andere reële getallen. Veel oudere F 77-programma's gebruiken deze impliciete regels, maar programmeurs zouden dit niet moeten doen omdat de kans op programmafouten dramatisch toeneemt als ze variabelen inconsistent declareren.

Fortran 77 heeft slechts één type voor integer-variabelen. Gehele getallen worden doorgaans opgeslagen als variabelen van 32 bits (4 bytes). Daarom moeten alle integer-variabelen waarden aannemen in het bereik [-m, m], waarbij m ongeveer 2 * 10 9 is.

F 77 heeft er twee verschillende soorten voor drijvende-kommavariabelen, echte dubbele precisie genoemd. Sommige numerieke berekeningen vereisen een zeer hoge nauwkeurigheid en er moet dubbele precisie worden gebruikt. Normaal gesproken is real een variabele van 4 bytes en de dubbele precisie is 8 bytes, maar dit hangt af van de machine.

Niet-standaardversies van Fortran gebruiken de syntaxis real*8 om te verwijzen naar drijvende-kommavariabelen van 8 bytes. Sommige constanten komen vele malen voor in een programma. Daarom is het raadzaam om ze slechts één keer te definiëren, aan het begin van het programma. Hiervoor wordt de parameteroperator gebruikt. Het maakt programma's ook beter leesbaar. Een programma voor de oppervlakte van een cirkel moet bijvoorbeeld zo worden geschreven.

Syntaxis van parameteroperator (naam = constante, ..., naam = constante). Regels voor de parameteroperator:

1. Een "variabele" die in een parameterinstructie wordt gedefinieerd, is geen variabele, maar een constante waarvan de waarde nooit kan veranderen.
2. "Variabele" kan maximaal één parameterinstructie weergeven.
3. De operatorparameter moet vóór de eerste uitvoerbare operator komen

Enkele goede redenen om een ​​parameter te gebruiken - helpt typefouten te verminderen, eenvoudig een constante te wijzigen die vaak in een programma voorkomt.

Booleaanse expressies kan alleen de waarde.TRUE hebben. of fout. en kan worden gevormd door vergelijking met behulp van relationele operatoren.

U kunt geen tekens gebruiken zoals '<» или «=» для сравнения в F 77, но можно использовать правильную двухбуквенную аббревиатуру, заключенную точками. Однако такие символы разрешены в Fortran 90.

Logische uitdrukkingen kunnen worden gecombineerd met de logische operatoren “AND”, “OR”, “NOT”, die een duidelijke betekenis hebben. Waarheidswaarden kunnen worden opgeslagen in Booleaanse variabelen. De opdracht is vergelijkbaar met de rekenkundige opdracht.

Voorbeeld: logisch a, ba = .TRUE.b = a .AND. 3.LT. 5/2

De volgorde van prioriteit is erg belangrijk. De regel is dat rekenkundige expressies eerst worden geëvalueerd, daarna relationele operatoren en ten slotte logische operatoren. Daarom krijgt b de waarde .FALSE. In het bovenstaande voorbeeld worden Booleaanse variabelen zelden gebruikt in Fortran, maar ze worden vaak gebruikt in voorwaardelijke instructies zoals de "if" -instructie.

Constant en doel

De eenvoudigste vorm van een uitdrukking is een constante. Er zijn 6 soorten constanten die overeenkomen met 6 gegevenstypen. Hier zijn enkele geheeltallige constanten: 10-10032767+15

Echte constanten: 1,0-0,252.0E63.333E-1.

E-notatie betekent het vermenigvuldigen van de constante met 10, verheven tot de macht volgend op de "E". Daarom is 2,0E6 gelijk aan twee miljoen en ongeveer een derde aan 3,333E-1. Voor constanten die groter zijn dan de grootste die feitelijk is toegestaan, of die een hoge nauwkeurigheid vereisen, moet dubbele precisie worden gebruikt. De notatie is hetzelfde als voor reële constanten, behalve dat "E" wordt vervangen door "D".

Voorbeeld:2.0D-11D99.

Hier is 2.0D-1 dubbele precisie met één vijfde, terwijl 1D99 één is, gevolgd door 99 nullen.

Het volgende type zijn complexe constanten. Ze worden aangegeven met een paar constanten (geheel getal of reëel), gescheiden door een komma en tussen haakjes.

Voorbeelden zijn: (2, -3)(1,9,9E-1). Het eerste getal geeft het reële deel aan, en het tweede het denkbeeldige deel.

Het vijfde type zijn logische constanten. Ze kunnen slechts één van twee betekenissen hebben:

Houd er rekening mee dat er punten met letters moeten worden geschreven.

Het laatste type zijn karakterconstanten. Ze worden meestal gebruikt als een reeks tekens, een zogenaamde string. Ze bestaan ​​uit een willekeurige reeks tekens tussen apostrofs (enkele aanhalingstekens):

"Alles gaat!"

"Het is een mooie dag"

Tekenreeks- en tekenconstanten zijn hoofdlettergevoelig. Het probleem doet zich voor als u een echte apostrof in de regel zelf wilt hebben. In dit geval moet u de apostrof verdubbelen: "Het" "het is een mooie dag", wat betekent "Wat een prachtige dag"

Voorwaardelijke instructies zijn belangrijke componenten van elke programmeertaal. De meest voorkomende van deze uitspraken in Fortran is de 'if'-instructie, die feitelijk verschillende vormen heeft.

De eenvoudigste is de logische uitdrukking “if” in de Fortran-beschrijving: if (logische uitdrukking) uitvoerbare instructie.

Dit moet op één regel worden geschreven, bijvoorbeeld bij het bepalen van de absolute waarde van x:

als (x .LT. 0) x = -x

Als er meer dan één instructie moet worden uitgevoerd in een "if", moet de volgende syntaxis worden gebruikt: if (logische uitdrukking) thenstatementsendif.

Uitvoeringsstroom van boven naar beneden. Voorwaardelijke expressies worden opeenvolgend geëvalueerd totdat een echte waarde wordt gevonden. De juiste code wordt vervolgens uitgevoerd en de besturing gaat naar de volgende instructie na het einde "if".

If-instructies kunnen op meerdere niveaus worden genest. Om de leesbaarheid te garanderen, is het belangrijk om de juiste inspringing te gebruiken. Hier is een voorbeeld:

if (x .GT. 0) thenif (x .GE. y) thenwrite(*,*) "x is positief en x >= y"elsewrite(*,*) "x is positief maar x< y"endifelseif (x .LT. 0) thenwrite(*,*) "x is negative"elsewrite(*,*) "x is zero"endif

Programmeurs moeten vermijden dat er veel niveaus van "if"-instructies worden genest, omdat dit moeilijk te volgen zal zijn.

Je kunt elk Unix-werkstation gebruiken met een compiler F 77. Ervaren programmeurs raden aan om Sun of Dec te gebruiken.

Een Fortran-programma bestaat uit platte tekst die bepaalde syntaxisregels volgt. Dit heet broncode. Programmeurs gebruiken een editor om broncode te schrijven. De meest voorkomende editors op Unix zijn emacs en vi, maar ze kunnen een beetje ingewikkeld zijn voor beginnende gebruikers. U kunt een eenvoudiger editor gebruiken, zoals xedit, die onder X-windows draait.

Zodra een Fortran-programma is geschreven, wordt het opgeslagen in een bestand met de extensie “.f” of “.for” en wordt het programma omgezet in een machinaal leesbare vorm. Dit gebeurt met behulp van een speciaal programma, een compiler. De Fortran 77-compiler wordt gewoonlijk f77 genoemd. De compilatie-uitvoer krijgt standaard de enigszins cryptische naam "a.out", maar u kunt indien nodig een andere naam kiezen. Om het programma uit te voeren, voert u eenvoudig de naam van het uitvoerbare bestand in, bijvoorbeeld "a.out". De compiler vertaalt de broncode naar objectcode en de linker of loader vertaalt deze naar een uitvoerbaar bestand. Zoals u kunt zien, is deze procedure helemaal niet ingewikkeld en voor elke gebruiker toegankelijk.

Simulatie is een van de meest gebruikte productiemethoden en andere systemen in moderne fabrieken. De meeste simulatiemodellen worden gebouwd met behulp van de objectgeoriënteerde programmeertaal Actor Fortran, of een simulatiesoftwarepakket geschreven in een traditionele taal. Deze hulpmiddelen hebben hun beperkingen. Objectgeoriënteerde technologie wordt op veel gebieden steeds vaker toegepast en belooft een flexibelere en efficiëntere benadering van het modelleren van bedrijfssystemen.

Simula Fortran-programmering wordt vergeleken met een conventionele wetenschappelijke programmeertaal genaamd FORTRAN. Een typisch militair simulatiemodel is geprogrammeerd in zowel SIMULA als FORTRAN. Het SIMULA-programma was 24% korter dan de FORTRAN-versie.

De SIMULA-versie is ook eenvoudiger en geeft een beter beeld van het model dat wordt gesimuleerd. Aan de andere kant is de uitvoeringstijd voor productieruns 64% sneller met de objectgeoriënteerde programmeertaal Simula Fortran. Uit een afweging van de voor- en nadelen blijkt dat SIMULA steeds winstgevender software zal worden, met hogere personeelskosten en lagere computerkosten.

CUDA laat zien hoe krachtige applicatieontwikkelaars de kracht van GPU's kunnen benutten met behulp van Fortran, een gemeenschappelijke taal voor wetenschappelijk computergebruik en het testen van supercomputerprestaties. De auteurs gaan niet uit van enige eerdere ervaring met parallel computergebruik en behandelen alleen de basisprincipes en best practices. De rekenefficiëntie van GPU's die CUDA Fortran gebruiken, wordt mogelijk gemaakt door de doel-GPU-architectuur.

CUDA Fortran for Scientists and Engineers zal rekenintensieve delen van de code identificeren en de code aanpassen voor gegevensbeheer, parallellisme en prestatie-optimalisatie. Dit alles gebeurt in Fortran, zonder dat het programma in een andere taal hoeft te worden herschreven. Elk concept wordt geïllustreerd met concrete voorbeelden, zodat u de prestaties van de code onmiddellijk kunt evalueren.

Misschien zal de mondiale onderneming op een dag ‘eindelijk globaliseren’ en besluiten dat Fortran niet langer nodig is, maar niet nu. Dankzij de huidige mogelijkheden van het moderne Fortran zien veel programmeurs en wetenschappers het als de toekomst. Bovendien zijn er genoeg fabrikanten in de wereld die leven van het ontwikkelen van moderne compilers en goed geld verdienen aan dit proces.