2.2. Ett enkelt Fortran-program
Vi kommer nu att g˚a in p˚a grunderna till programmering, och v¨aljer Fortran som programmeringsspr˚ak, dels f¨or att det ¨ar det mest anv¨anda f¨or numeriska ber¨akningar i fysik och teknik, och dels f¨or att standarden nyligen moderniserats. Vi kommer h¨ar att f¨olja den nya standarden, Fortran 90 (Fortran 95 skiljer sig endast obetydligt fr˚an Fortran 90), och endast tillf¨alligt ber¨ora den ¨aldre standarden, FORTRAN 77, som fortfarande anv¨andes.
I f¨oreg˚aende avsnitt har vi redan i princip beskrivit hur man g˚ar till v¨aga f¨or att skriva ett program. Det ¨ar viktigt att specificera problemet s˚a v¨al, att det blir l¨att att koda. En enkel programkod ¨ar ocks˚a l¨attare att fels¨oka. Sedan man bortskaffat alla syntaktiska fel efter kompileringen, skall programmet l¨ankas och testas.
Fel som uppt¨acks vid testningen, r¨attas genom att k¨allkoden ¨andras. Detta ¨ar oftast den mest kr¨avande delen av programmeringen.
Vi skall b¨orja med att studera ett enkelt exempel p˚a ett Fortran-program, som har till uppgift att ber¨akna medelpunkten och radien f¨or en cirkel, som g˚ar genom tre givna punkter. Programmet ¨ar skrivet med en str¨ang Fortran 90 syntax, vilket inneb¨ar, att det kan kompileras med en Fortran-kompilator (t.ex. ELF90
En fri kompilator f¨or Fortran 95/2003 ¨ar GNU Fortran, som ¨aven kan installeras i Windows (se http://gcc.gnu.org/wiki/GFortran). Den ¨overs¨atter ocks˚a FORTRAN 77-kod.
Vi skall f¨orst se p˚a huvudprogrammet, som l¨aser in punkter, anropar en subrutin, som ber¨aknar medel- punkten och radien, och slutligen skriver ut resultatet.
PROGRAM cirkel IMPLICIT NONE
! Detta program ber¨aknar medelpunkten och radien
! f¨or en cirkel genom tre givna punkter
! Deklarationer
REAL :: x1,y1,x2,y2,x3,y3,x0,y0,r INTEGER :: ier
! Explicit interface (elf90) interface
subroutine calcrk (a1, b1, a2, b2, a3, b3, x, y, r, i) implicit none
real, intent(in) :: a1, b1, a2, b2, a3, b3 real, intent(out) :: x, y, r
integer, intent(out) :: i
end subroutine calcrk end interface
! L¨as in punkterna
PRINT *, "Skriv koordinaterna f¨or tre punkter"
PRINT *, "i ordningen x1,y1,x2,y2,x3,y3"
READ *, x1,y1,x2,y2,x3,y3
! Ber¨akna medelpunkten och radien
CALL calcrk(x1,y1,x2,y2,x3,y3,x0,y0,r,ier)
! Skriv ut medelpunkten och radien, om allt g˚att v¨al:
IF (ier == 0) THEN
PRINT *, "Cirkelns medelpunkt ¨ar (",&
& x0,",",y0,")"
PRINT *, "och dess radie = ",r ELSE
PRINT *, "Punkterna ¨ar p˚a r¨at linje, "&
& , "eller n˚agra av dem sammanfaller!"
END IF STOP
Programmet har skrivits i princip i fritt format, vilket inneb¨ar, att man inte beh¨over f¨asta st¨orre avseende vid vilka kolumner som inneh˚aller programinstruktioner, till ˚atskillnad fr˚an det fasta formatet som g¨aller i FORTRAN 77.
Kommentarer anges med utropstecken (!), och de f˚ar ocks˚a st˚a efter en instruktion p˚a samma rad. F¨or att forts¨atta en instruktion p˚a n¨asta rad anv¨ands tecknet ”&” som sista tecken p˚a raden, och det b¨or oftast upprepas p˚a f¨oljande rad.
I Fortran 90 kan man anv¨anda f¨oljande tecken (undantag g¨ors f¨or kommentarer, och text som skall skrivas ut):
ABCDEFHIJKLMONPQRSTUVWXYZ0123456789
t=+-*/(),.$ ’:!"%& ; <>?
d¨ar t anv¨ants f¨or att beteckna ett mellanrum. Tecknet f˚ar dessutom anv¨andas i namn.
Om vi studerar programmet litet n¨armare, kan vi konstatera att det b¨orjar med instruktionen PROGRAM cirkel, och avslutas med END PROGRAM CIRKEL. Instruktionen PROGRAM anger programmets namn.
Detta namn f¨oljer reglerna f¨or symbolnamn i Fortran: Det m˚aste b¨orja med en bokstav, och f˚ar endast inneh˚alla bokst¨aver och siffror. Medan FORTRAN 77 endast till¨at sex tecken i symbolnamn, till˚ater Fortran 90 numera 31 tecken.
Fortran tolkar normalt alla variabler, vilkas namn b¨orjar med n˚agon av bokst¨averna A-H och O-Z som decimaltal (reella variabler), och alla ¨ovriga variabler som heltal, om man inte deklarerar dem p˚a ett annat s¨att. Detta kallas implicit deklaration.
F¨or att undvika detta, borde man anv¨anda IMPLICIT NONE, vilket leder till, att alla variabler som anv¨ands, m˚aste deklareras (F till˚ater inte IMPLICIT–deklarationen). F¨ordelen med detta ¨ar, att odeklarerade variabler genast observeras av kompilatorn, vilket underl¨attar fels¨okningen.
Exempel p˚a variabeldeklarationer syns p˚a de f¨oljande raderna:
REAL :: x1,y1,x2,y2,x3,y3,x0,y0,r INTEGER :: ier
d¨ar f¨orst koordinaterna f¨or de tre punkterna, och sedan koordinaterna f¨or medelpunkten, samt radien deklareras reella. Variabeln ier anger en felkod, som levereras av rutinen som ber¨aknar cirkelns medelpunkt och radie.
D¨arefter f¨oljer ett s.k. interface-block, som anv¨ands f¨or att beskriva subrutinens variabler. Det ¨ar inte obligatoriskt, men rekommenderas i Fortran 90. Med intent kan man ange om variablerna anv¨andes f¨or inmatning eller utmatning.
De f¨oljande instruktionerna, som ¨ar de f¨orsta som verkligen utf¨ors, styr inmatningen. Instruktionerna
PRINT *, "Skriv koordinaterna f¨or tre punkter"
PRINT *, "i ordningen x1,y1,x2,y2,x3,y3"
ger en uppmaning p˚a sk¨armen till anv¨andaren att skriva ut koordinaterna f¨or de tre punkterna.
Observera, att texten, som skall skrivas ut, begr¨ansas av citationstecken " eller apostrofer ’ i Fortran 90.
Den f¨oljande instruktionen READ *, x1,y1,x2,y2,x3,y3 l¨aser in talen, som matas in, varp˚a subrutinen, som g¨or den egentliga utr¨akningen anropas:
CALL calcrk(x1,y1,x2,y2,x3,y3,x0,y0,r,ier).
D˚a instruktionen CALL utf¨ors, kommer utf¨orandet av programmet tillf¨alligt att avbrytas, och kontrollen
¨overflyttas till subrutinen calcrk. Symbolnamnen, som befinner sig inom parentes efter subrutinens namn, kallas argument, och anv¨ands f¨or att ¨overf¨ora information till subrutinen (i detta fall de tre punkternas koordinater), samt f¨or att ta emot den information, som ges av rutinen efter avslutad r¨akning (i detta fall medelpunktens koordinater och radien).
Variabeln ier ¨ar = 0, om subrutinen lyckats r¨akna ut cirkelns medelpunkt och radie. Om detta misslyckas (t.ex. om de givna punkterna ligger p˚a en r¨at linje), f˚ar ier v¨ardet 1. V¨ardet av ier kan man testa med villkorssatsen IF:
IF (ier == 0) THEN ...
ELSE ...
END IF
Om ier = 0, s˚a skrivs resultatet av ber¨akningen ut med instruktionerna PRINT *, "Cirkelns medelpunkt ¨ar (",&
& x0,",",y0,")"
PRINT *, "och dess radie = ",r
Observera textens indragning, vilket underl¨attar l¨asningen! H¨ar visas ocks˚a, hur man kan ange att instruk- tionen forts¨atter p˚a n¨asta rad. Om ier 6= 0, skrivs ett felmeddelande ut:
PRINT *, "Punkterna ¨ar p˚a r¨at linje, "&
& , "eller n˚agra av dem sammanfaller!"
och programmet avslutas.
F¨or att kunna anv¨anda detta program, m˚aste vi ocks˚a skriva subrutinen, som ber¨aknar cirkelns medelpunkt och radie. Detta sker genom att substituera de tre givna punkternas koordinater i cirkelns ekvation, och l¨osa ekvationssystemet
(x1 − x0)2 + (y1 − y0)2 = r2 (x2 − x0)2 + (y2 − y0)2 = r2 (x3 − x0)2 + (y3 − y0)2 = r2
En rutin som l¨oser detta ekvationssystem visas nedan utan n¨armare kommentarer:
SUBROUTINE calcrk(x1,y1,x2,y2,x3,y3,x0,y0,r,ier)
! Routine that computes the center and radius for a circle
! passing through three given points
! TS 1995-02-28
IMPLICIT NONE
REAL, intent(in) :: x1,y1,x2,y2,x3,y3 REAL, intent(out) :: x0,y0,r
REAL :: x12,y12,x13,y13 REAL :: r12,r13,a,b,d
INTEGER, intent(out) :: ier ier = 0
x12 = x1-x2 y12 = y1-y2 x13 = x1-x3 y13 = y1-y3
d = x12*y13 - x13*y12
! Test for collinear points:
IF (abs(d) > 0.) THEN
r12 = x12*(x1+x2) + y12*(y1+y2) r13 = x13*(x1+x3) + y13*(y1+y3) a = 0.5*r12/d
b = 0.5*r13/d
! Compute center and radius:
x0 = a*y13 - b*y12 y0 = -a*x13 + b*x12
r = sqrt((x1-x0)**2 + (y1-y0)**2) ELSE
ier = 1 END IF RETURN
END subroutine calcrk
(om man anv¨ander F, m˚aste subrutinen inb¨addas i en modul, n˚agot vi senare skall studera).
N¨ar man har skrivit subrutinen, kan man kompilera huvudprogrammet cirkel, och subrutinen calcrk.
Kompilering av Fortran-program g˚ar i princip till p˚a ett liknande s¨att p˚a alla datorer. Om vi som exempel v¨aljer det program, som vi nyss studerat, s˚a kan vi kompilera det med en f90-kompilator (jfr man f90) under HP Unix p˚a f¨oljande s¨att:
soul/home/pcu/fyl/sundius/test/f90> f90 -o cirkel cirkel.f90 calcrk.f90 soul/home/pcu/fyl/sundius/test/f90> dir c*
-rw--- 1 sundius fyl 850 Mar 3 1997 calcrk.f90
-rwx--- 1 sundius fyl 34656 Jan 31 15:51 cirkel*
-rw--- 1 sundius fyl 815 Mar 3 1997 cirkel.f90
-rw--- 1 sundius fyl 342 Dec 9 2004 complex.f90
-rw--- 1 sundius fyl 513 Dec 16 1999 cosfit.f90
I detta fall kommer kommandot f90 b˚ade att kompilera och l¨anka filen, och optionen -o anger namnet p˚a den exekverbara filen. Programmet k¨ors genom att man skriver filens namn (om inte katalogen ing˚ar i v¨agen, m˚aste man antingen f¨orst skriva setenv PATH "$PATH":., eller skriva ./cirkel, som alltid fungerar)
soul/home/pcu/fyl/sundius/test/f90> cirkel Skriv koordinaterna f¨or tre punkter
i ordningen x1,y1,x2,y2,x3,y3 1 3
5 3 3 -3
Cirkelns medelpunkt ¨ar ( 3.000000 , 0.3333333 ) och dess radie = 3.333333
Man kan ocks˚a kompilera filerna, och d¨arp˚a skilt linka de alstrade objektfilerna, som har extensionen .o (kompilerat med gfortran p˚a punk):
punk.it.helsinki.fi/home/pcu/fyl/sundius/test/f90> gfortran -c cirkel.f90 calcrk.f90 punk.it.helsinki.fi/home/pcu/fyl/sundius/test/f90> gfortran -o cirkel cirkel.o calcrk.o
Namnet p˚a den fil, som inneh˚aller k¨allkoden, har normalt extensionen .f90, men kan ocks˚a vara .f95, .f03 eller t.o.m. .f, beroende p˚a vad kompilatorn till˚ater. Om man inte ger n˚agot namn ˚at den exekverbara filen, kallas den av kompilatorn a.out, och k¨ors med kommandot ./a.out.
2.3. Konstanter och variabler i Fortran
Efter den korta introduktionen skall vi mera i detalj g˚a in p˚a Fortran-spr˚akets struktur. Vi skall b¨orja med att repetera framst¨allningen av tal. Vi har redan i olika sammanhang n¨amnt att datorerna r¨aknar med bin¨ara tal, s˚a att de egentligen bara k¨anner till heltal.
Ett bin¨art tal framst¨alls som en f¨oljd av ettor och nollor, som t.ex. 101101. Siffrorna brukar kallas bitar.
Varje bit svarar mot en bin¨ar siffra, s˚a att biten l¨angst till h¨oger (den minst signifikanta) anger antalet multipler av 20, den f¨oljande biten antalet multipler av 21, osv. Ist¨allet f¨or bin¨ar representation, brukar man ofta anv¨anda en hexadecimal framst¨allning, som inte kr¨aver s˚a m˚anga siffror.
Datorns minnesstorlek anges oftast i en annan enhet, n¨amligen byte, som ¨ar ˚atta bitar. Med en byte kan man inte framst¨alla tal st¨orre ¨an 255, och d¨arf¨or ¨ar den s.k. ordl¨angden vanligen minst 4 bytes (32 bitar).
Den mest signifikanta biten (dvs den som befinner sig l¨angst till v¨anster) anger f¨ortecknet.
Decimaltal (dvs reella tal) m˚aste ocks˚a framst¨allas i samma form. Detta ¨ar inte s˚a konstigt, eftersom varje decimaltal kan uttryckas som ett heltal g˚anger en tiopotens eller exponent (vi kan ocks˚a tolka det som en logaritmisk framst¨allning, med mantissa och karakt¨aristika). Om ordl¨angden ¨ar 32 bitar, s˚a reserveras vanligen 8 bitar f¨or exponenten, och 24 bitar f¨or mantissan (kallas ocks˚a f¨or en flyttalsrepresentation).
I verkligheten uppfattas mantissan som ett decimaltal (normaliserat till 1), och talet kan d˚a framst¨allas i formen a = r · 2m. Detta kallas ocks˚a f¨or IEEE-standarden. Exponenten uttrycks vanligen som ett heltal mellan 0 och 255, och 127 m˚aste subtraheras f¨or att man ocks˚a skall kunna framst¨alla negativa exponenter.
Det st¨orsta positiva tal som kan representeras med denna metod ¨ar s˚aledes ca 2127 ≈ 1038. P˚a grund av att mantissan inneh˚aller 24 bitar f˚ar man ca 7 decimalers noggrannhet i r¨akningarna.
Detta s¨att att framst¨alla tal med ett begr¨ansat antal siffror, leder till att man inte kan uttrycka vilka tal som helst. F¨or en dator med 32-bitars ordl¨angd begr¨ansas heltal till intervallet [−2 · 109, 2 · 109]. Reella tal ¨ar till sitt absoluta v¨arde begr¨ansade av intervallet [10−38, 1038], s˚a att verkligt stora eller sm˚a tal inte kan representeras korrekt av datorn. Tal som underskrider den nedre gr¨ansen ˚astadkommer underflow, medan tal som ¨overskrider den ¨ovre gr¨ansen ger upphov till overflow. I det senare fallet avbryts programmets utf¨orande automatiskt, medan underflow leder till att resultatet av r¨akneoperationen blir noll, vilket inte alltid observeras.
Fortran k¨anner till b˚ade numeriska och icke-numeriska konstanter (eller literala konstanter). De numeriska konstanterna kan vara heltaliga, reella eller komplexa. En heltalig konstant ¨ar ett tal, som saknar deci- malpunkt, medan en reell konstant har decimalpunkt, och kan efterf¨oljas av tecknet E och en heltalig exponent. 4., -1.5, 2.E-5, -4.E8 ¨ar exempel p˚a reella konstanter. En komplex konstant best˚ar av tv˚a reella tal inom parentes, ˚atskilda av ett komma : (4.51, -3.72).
De icke-numeriska konstanterna ¨ar logiska konstanter och teckenkonstanter. De logiska konstanterna ¨ar tv˚a: .TRUE. och .FALSE. (observera punkten f¨ore och efter!). En teckenkonstant anges i Fortran som en teckenstr¨ang omgiven av citationstecken (eller apostrofer): "Detta ¨ar en teckenkonstant". Om teckenstr¨angen inneh˚aller ett citationstecken, upprepas det: "Descartes"" filosofi" (detta problem undviks i Fortran 90, d¨ar man ocks˚a kan anv¨anda apostrofer: "Descartes’ filosofi").
En variabel ¨ar en storhet som kan definieras och omdefinieras under programexekveringen. I Fortran m˚aste den alltid ha ett namn. En variabel har alltid en datatyp, som i Fortran 90 deklareras p˚a f¨oljande s¨att : TYP :: namn (det dubbla kolonet saknas i FORTRAN 77), d¨ar TYP anger datatypens namn, och namn ¨ar variabelns namn. Tre reella variabler a,b,c anges med instruktionen REAL :: a,b,c, och tv˚a heltal i,j med instruktionen INTEGER :: i,j. Om typen f¨or en variabel inte ¨ar angiven, antog Fortran-kompilatorn f¨orr automatiskt att en variabel, vars namn b¨orjar med I-N, ¨ar av heltalstyp, medan alla ¨ovriga ¨ar reella variabler. Detta undvikes i Fortran 90 genom att anv¨anda deklarationen IMPLICIT NONE. Man m˚aste d˚a deklarera alla variabler i programmet, men samtidigt underl¨attar man uppt¨ackten av typografiska fel vid kompileringen.
En variabel kan definieras antingen genom att den tilldelas ett v¨arde, eller genom en READ-instruktion.
Tilldelningen sker genom en instruktion av formen namn = uttryck, d¨ar namn anger variabelnamnet, och uttryck ¨ar ett uttryck, som efter utr¨akning f˚ar ett best¨amt v¨arde.
Uttrycket f˚ar inneh˚alla operander, operatorer och parenteser. Ett exempel p˚a en dylik tilldelningssats ¨ar a = b + c, d¨ar variabeln a tilldelas v¨ardet av summan b + c. I detta uttryck ¨ar variablerna b och c operander, medan + ¨ar en operator.
Om vi antar att alla variabler a, b och c ¨ar reella, s˚a f˚ar variabeln a ett v¨arde, som ¨ar mycket n¨ara den exakta summan av b och c (observera, att datorn alltid r¨aknar med ¨andlig precision). Men om t.ex.
variabeln a ¨ar heltalig, s˚a m˚aste resultatet av r¨akneoperationen f¨orst avkortas till ett heltal, innan variabeln a tilldelas ett v¨arde. Detta kallas f¨or stympning av resultatet, och kan ocks˚a intr¨affa vid heltalsdivision, som vi strax skall se.
Fortran har fem aritmetiska operatorer: + (addition), - (subtraktion), * (multiplikation), / (division) och
** (potensering). Genom kombination av dessa operatorer med godtyckliga operander kan man i princip
˚astadkomma hur invecklade uttryck som helst. Men det ¨ar inte alltid alldeles klart, hur ett s˚adant uttryck r¨aknas ut.
L˚at oss t.ex. betrakta a = b*c+d/e-f**g+h. F¨or att g¨ora det l¨attare att tolka ett s˚adant uttryck, har man inf¨ort vissa prioritetsregler, som ¨overensst¨ammer med dem som anv¨ands i matematiken. H¨ogsta pri- oritet ges ˚at potensering (och funktionsber¨akningar, om s˚adana f¨orekommer i uttrycket), l¨agre prioritet ˚at multiplikation och division, och den l¨agsta prioriteten ges ˚at addition och subtraktion.
Uttrycket ovan kan allts˚a tolkas p˚a f¨oljande s¨att: F¨orst utf¨ors operationen f**g, och resultatet sparas i en tillf¨allig variabel, som vi kan kalla tmp1. Sedan ber¨aknas b*c, som sparas i tmp2, samt d/e, som sparas i tmp3. Sedan adderas tmp2 och tmp3, och resultatet sparas i tmp4. D¨arp˚a subtraheras tmp1 fr˚an tmp4, och resultatet sparas i tmp5. Slutligen adderas tmp5 och h, och resultatet tilldelas variabeln a.
Prioritetsordningen kan f¨or¨andras, liksom i vanlig matematik, genom att anv¨anda parenteser. S˚alunda kan vi f˚a ett helt annat resultat genom att skriva ovanst˚aende uttryck t.ex. i formen a = (b*c+d)/(e-f**g)+h.
Vad h¨ander om alla operander inte ¨ar av samma typ? Vi kan t.ex betrakta uttrycket a = b*c/d, d¨ar t.ex.
b ¨ar reell och har v¨ardet 5.0, medan c och d ¨ar heltaliga och har v¨ardena 4 och 8. Emedan multiplikation och division har samma prioritet, kommer ber¨akningen att utf¨oras fr˚an v¨anster till h¨oger, dvs vi ber¨aknar f¨orst b*c efter att ha konverterat c till ett decimaltal (4.0), och dividerar sedan resultatet med d, som f¨orst konverterats till decimaltal (8.0). Variabeln a f˚ar allts˚a v¨ardet 2.5.
Om vi skriver f¨oreg˚aende uttryck i formen a = c/d*b, som ¨ar matematiskt ekvivalent med den ursprungliga formen, kommer vi f¨orst att ber¨akna uttrycket c/d, som nu ber¨aknas som en heltalsdivision 4/8, avkortat till 0! D¨arp˚a multipliceras resultatet (efter konvertering till ett decimaltal) med b, men eftersom resultatet av heltalsdivisionen var noll, kommer ocks˚a variabeln a att tilldelas v¨ardet 0. Detta visar, att man b¨or undvika att blanda typer, om man inte s¨akert vet vad som h¨ander.
Vi skall studera ett annat exempel p˚a tillordningar av variabler, n¨amligen ber¨akning av sin, cos och tan f¨or en vinkel i en r¨atvinklig triangel, d¨ar kateterna a och b ¨ar givna. Om vinkeln betecknas θ, a ¨ar den n¨arliggande kateten och b den motst˚aende kateten, s˚a g¨aller som bekant
cos θ = a
√a2 + b2 sin θ = b
√a2 + b2 tan θ = b
a
Om a = 3 och b = 4 (t.ex.) s˚a kan programmet skrivas
PROGRAM Triangle IMPLICIT NONE
REAL :: A,B,C,COST,SINT,TANT A = 3.0
B = 4.0
C = (A*A + B*B)**0.5 COST = A/C
SINT = B/C TANT = B/A
PRINT * ,COST,SINT,TANT STOP
END PROGRAM Triangle
Som vi ser, har kvadratroten (som ger triangelns hypotenusa) r¨aknats skilt f¨or sig. Ist¨allet f¨or att r¨akna den med potensr¨akning, kunde vi ha r¨aknat den med kvadratrotsfunktionen, men i detta fall har det inte s˚a stor betydelse. Ofta g˚ar det snabbare att r¨akna en kvadrat via multiplikation, s˚asom i detta fall (A*A ist¨allet f¨or A**2). Om man m¨arker att en del av ett uttryck f¨orekommer p˚a flere st¨allen i programmet (s˚asom i detta fall uttrycket f¨or hypotenusan) l¨onar det sig att r¨akna ut det skilt f¨or sig.
Ett annat exempel ¨ar l¨osningen till en andra gradens ekvation. Om ekvationen ¨ar ax2 + bx + c = 0, s˚a vet vi att r¨otterna kan skrivas
x = − b
2a ± 1 2a
pb2 − 4ac
Ett program som l¨oser en andra gradens ekvation med reella r¨otter visas p˚a n¨asta sida. Programmet kontrollerar ocks˚a ifall diskriminanten ¨ar st¨orre, eller lika med noll.
PROGRAM Rot IMPLICIT NONE
REAL :: A,B,C,D,X1,X2
PRINT *, "Ange koefficienterna A,B,C:"
READ *, A,B,C D = B*B - 4.*A*C IF (D >= 0) THEN
X1 = (-B + SQRT(D))/(2.*A) X2 = (-B - SQRT(D))/(2.*A) PRINT *, "R¨otterna ¨ar:"
PRINT *, "X1 = ",X1, "X2 = ",X2 ELSE
PRINT *, "Inga reella r¨otter!"
END IF STOP
END PROGRAM Rot
H¨ar ser vi hur man kan testa v¨ardet av diskriminanten (d = b2 − 4ac) f¨or att ta reda p˚a, om r¨otterna ¨ar reella eller ej. IF-instruktionen inneh˚aller h¨ar ett logiskt uttryck D >= 0 (d ≥ 0) som antingen ¨ar sant eller falskt. Ett problem i Fortran har varit att den uppn˚aeliga precisionen ¨ar maskinberoende. I Fortran 90
Vi skall se p˚a ett annat exempel, d¨ar vi skall ber¨akna summan av serien
s =
∞
X
i=1
1
i2 = π2
6 ≈ 1.6449341
Programmet ser ut p˚a f¨oljande s¨att:
PROGRAM serie IMPLICIT NONE REAL :: s = 0.
INTEGER :: i, n
PRINT *, ’Ange antalet termer:’
READ *, n
PRINT *, ’Antalet termer: ’,n DO i=1,n
s = s + 1./REAL(i)**2 END DO
PRINT *, ’Termernas summa: ’,s END PROGRAM serie
Programmet visar en enkel slinga, som man kan bilda med en DO-loop. Variabeln s ¨ar, som synes, initiali- serad till 0. Funktionen REAL f¨orvandlar ett heltal till ett reellt tal. Vi kan testa programmet t.ex. genom att r¨akna summan av 100 termer:
Ange antalet termer:
100
Antalet termer: 100
Termernas summa: 1.634984
Om vi g¨or r¨akningen med 1000 termer blir resultatet 1.643935, och med 10000 termer 1.644725.
Samma resultat f˚as f¨or 100000 termer. Vi tappar tydligen noggrannhet (en l¨osning ¨ar att summera termerna i motsatt ordning, kan du se varf¨or?).
