Vi har redan nämnt att det finns inbyggda funktioner i Fortran, och

forts. på föregående föreläsning:
Vi har redan nämnt att det finns inbyggda funktioner i Fortran, och har också redan använt några av de
matematiska funktionerna, såsom ABS, SQRT och SIN. Vi skall nu studera dem i litet mera detalj.
Inbyggda funktioner behöver i allmänhet inte typdeklareras, eftersom de är kända av systemet, och typen
framgår oftast av argumentet. Därför behöver de inte heller något explicit gränssnitt. I detta sammanhang
kan nämnas, att många av de inbyggda funktionerna förr användes med specifika namn, som var beroende av
argumentets typ. Numera rekommenderas att man använder det s.k. generiska namnet, som är oberoende av
argumentets typ. Som exempel kan nämnas ABS-funktionen. Om argumentet är heltaligt, kan man använda
det specifika namnet IABS, och om argumentet är komplext, så kan man använda det specifika namnet
CABS, men enklast kommer man undan, om använder det generiska namnet ABS, som kan användas
oberoende av argumentets typ. I Fortran 90 är det också möjligt att deklarera egna generiska funktioner
med lämpliga gränssnitt. Några funktioner har flera argument, och de bör i såfall vara av samma typ (t.ex.
båda heltaliga, eller båda reella).
Fortran 90 har ett stort antal inbyggda funktioner. Vi skall härnedan ge en förteckning över de generiska
namnen för de vanligaste av dem jämte en kort förklaring av deras användning.
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
1
Generiskt namn
ABS(X)
ACOS(X)
ADJUSTL(A)
ADJUSTR(A)
AIMAG(Z)
ASIN(X)
ATAN(X)
ATAN2(Y,X)
CEILING(X)
CHAR(I)
CMPLX(X,Y)
CONJG(Z)
COS(X)
COSH(X)
DBLE(X)
DOT PRODUCT(U,V)
EPSILON(X)
EXP(X)
FLOOR(X)
Betydelse
Absoluta värdet av X
Arcus cosinus(X), den vinkel 0 ≤ a ≤ π för vilken cos(a) = X
Vänsterjusterar strängen A
Högerjusterar strängen A
Imaginära delen av det komplexa talet Z
Arcus sinus(X), den vinkel −π/2 ≤ a ≤ π/2 för vilken sin(a) = X
Arcus tangenten (X), den vinkel −π/2 ≤ a ≤ π/2 för vilken tan(a) = X
Arcus tangenten (X), den vinkel −π ≤ a ≤ π för vilken tan(a) = Y /X
Det minsta heltalet, som är ≥ X
Tecknet, vars ASCII-kod är I
Bildar det komplexa talet X + iY
Konjugattalet för det komplexa talet Z
Cosinus (X)
Cosinus hyperbolicus (X), (eX + e−X )/2
Konverterar X till dubbel precision
Skalärprodukten av vektorerna u och v
Ett mycket litet tal, jämfört med 1 (ca 10−7)
Exponentialfunktionen ex
Största heltalet ≤ X
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
2
FRACTION(X)
HUGE(X)
IAND(i,j)
IBCLR(i,n)
IBSET(i,n)
ICHAR(A)
INT(X)
IOR(i,j)
LEN(A)
LEN TRIM(A)
LOG(X)
LOG10(X)
MATMUL(A,B)
MAX(X,Y,...)
MIN(X,Y,...)
MOD(X,Y)
NINT(X)
NOT(I)
RANDOM NUMBER(X)
Bråktalsdelen av talet X
Det största talet som kan framställas (ca 1038)
Bitvis logiskt AND av i och j
Nollställer biten n i heltalet i
Sätter bit n till 1 i heltalet i
ASCII-koden för tecknet A
Avkortning av ett reellt tal till heltal
Bitvis OR av heltalen i och j
Längden av strängen A
Längden av strängen A utan blanka tecken på slutet
Naturliga logaritmen av X : ln x
Briggska logaritmen av X : log x
Matrisprodukten av matriserna A och B
Maximivärdet av X, Y, . . .
Minimivärdet av X, Y, . . .
Resten av X/Y , dvs X - FLOOR(X/Y)*Y (X reellt)
Heltalet närmast X: INT(X + SIGN(0.5,X))
Ger logiska komplementet av argumentet I
Subrutin, som beräknar pseudoslumptal
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
3
RANDOM SEED(size, put,get)
REAL(I)
RESHAPE(X,S)
SCALE(X,I)
SIGN(X,Y)
SIN(X)
SINH(X)
SIZE(A)
SQRT(X)
SUM(A,n)
TAN(X)
TANH(X)
TINY(X)
TRANSPOSE(A)
TRIM(A)
Används för att starta RANDOM NUMBER
Konversion av ett heltal I till ett reellt tal
Funktion för att konstruera en matris från en vektor X
Multiplicerar X med 2I
Utbyte av tecken, dvs (Y:s tecken)*ABS(X)
Sinus (X)
Sinus hyperbolicus (X), (eX − e−X )/2
Ger antalet element i matrisen A
Kvadratroten ur X
Summan av elementen i matrisen A längs dimensionen n
Tangenten av X
Tangens hyperbolica, (eX − e−X )/(eX + e−X )
Det minsta tal som kan representeras (ca 10−38)
Transponering av matrisen A
Stryker blanka sluttecken från strängen A
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
4
Som exempel på användningen av matematiska funktioner för heltalsaritmetik skall vi studera ett program,
som söker upp alla primtal mellan 1 och 100. Metoden baserar sig på att ett udda heltal n är ett primtal,
√
ifall det inte är jämnt delbart med något udda heltal mellan 3 och n. Vi ser också ett exempel på, hur
man kan namnge DO-slingor för att flytta kontrollen från den inre till den yttre slingan med CYCLE.
PROGRAM Primtal
! Program för att uppsöka primtal mellan 1 och 100
IMPLICIT NONE
INTEGER :: n,k
PRINT *, ’Primtalen mellan 1 och 100:’
PRINT *, 1,2
yttre: DO n = 3,99,2
inre: DO k = 3, nint(sqrt(real(n))), 2
IF (mod(n,k) .eq. 0) CYCLE yttre
END DO inre
! Talet n är ett primtal!
PRINT *, n
END DO yttre
STOP
END PROGRAM Primtal
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
5
Moduler kallas ett helt nytt slag av programenheter som inte fanns i tidigare Fortran-versioner. En modul
inleds med en sats av formen MODULE namn, och avslutas av END MODULE namn (eller END MODULE).
Ändamålet med en modul är att göra de variabler, som där deklareras tillgängliga för andra programenheter. Modulerna möjliggör alltså global tillgänglighet för variabler och konstanter, och kan sålunda ersätta
COMMON-blocken i FORTRAN 77.
För att kunna använda variablerna i en modul i en subrutin, används USE-satsen, som bör stå i början av det
anropande programmet. Som ett exempel skall vi studera en enkel modul, som definierar några konstanter
och variabler, och hur denna modul används i en subrutin. Antag, att modulen ser ut så här:
MODULE testdata
IMPLICIT NONE
SAVE
! Konstanter
REAL, PARAMETER :: c=2.9979E8,
! Variabler
REAL :: data_1, data_2, data_3
END MODULE testdata
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
pi=3.14159
JJ J I II ×
6
En subrutin, som använder dessa data skulle kunna börja såhär:
SUBROUTINE sub
USE testdata
IMPLICIT NONE
( andra deklarationer)
...
( utförbara satser)
...
END SUBROUTINE sub
Som man lätt inser, är moduler speciellt viktiga i stora program med många subrutiner, som ofta behandlar
samma data. Användningen av moduler gör argumentlistorna kortare. Observera användningen av SAVEsatsen i modulen. Det är för att data med säkerhet skall bevaras under programkörningen.
Som ytterligare ett exempel skall vi skriva om programmet som beräknar summan av två tal genom att
använda en modul, som gör variablerna globalt tillgängliga.
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
7
MODULE global
IMPLICIT NONE
REAL :: A,B,C
END MODULE global
PROGRAM addtest
USE global
IMPLICIT NONE
interface
SUBROUTINE add
USE global
IMPLICIT NONE
END SUBROUTINE add
end interface
PRINT *, "Input a,b:"
READ *, A,B
CALL ADD
PRINT *, C
END PROGRAM addtest
SUBROUTINE add
USE global
IMPLICIT NONE
C = A + B
RETURN
END SUBROUTINE add
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
8
Satsen USE kan också användas i en annan modul, varigenom deklarationerna i den första modulen blir
tillgängliga i den andra, och en subrutin som använder den andra modulen, får därmed också automatiskt
tillgång till den andra modulens data. Detta belyses av nedanstående exempel:
MODULE nummer_ett
IMPLICIT NONE
SAVE
REAL :: tal_ett
END MODULE nummer_ett
MODULE nummer_tva
USE nummer_ett
IMPLICIT NONE
SAVE
REAL :: tal_tva
END MODULE nummer_tva
SUBROUTINE test
USE nummer_tva
IMPLICIT NONE
REAL :: x
x = tal_ett + tal_tva
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
9
Moduler kan också använda för att göra det bekvämare att använda explicita gränssnitt, vilket visas av
följande exempel:
MODULE granssnitt
INTERFACE
SUBROUTINE rutin1 (A,B,C)
IMPLICIT NONE
....
END SUBROUTINE rutin1
SUBROUTINE rutin2 (X,Y)
IMPLICIT NONE
...
END SUBROUTINE rutin2
END INTERFACE
END MODULE granssnitt
PROGRAM test
USE granssnitt
IMPLICIT NONE
....
CALL RUTIN1 (Q,R,S)
CALL RUTIN2 (V,W)
...
END PROGRAM test
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
10
Man kan också inkapsla procedurer i en modul med hjälp av CONTAINS-satsen. Med hjälp av USE-satsen
kan man sedan göra dem tillgängliga i ett program som anropar dem, och behöver då inte använda ett
explicit gränssnitt. Besläktade rutiner kan inneslutas i samma modul, och var och en av dem har ett explicit
gränssnitt till de andra procedurerna i modulen. Programexemplet ovan skulle alltså också kunna skrivas
MODULE procedurer
IMPLICIT NONE
CONTAINS
SUBROUTINE rutin1 (A,B,C)
IMPLICIT NONE
....
END SUBROUTINE rutin1
SUBROUTINE rutin2 (X,Y)
IMPLICIT NONE
...
END SUBROUTINE rutin2
END MODULE procedurer
PROGRAM test
USE procedurer
IMPLICIT NONE
....
CALL RUTIN1 (Q,R,S)
CALL RUTIN2 (V,W)
...
END PROGRAM test
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
11
Ett mera konkret exempel på användningen av modulprocedurer visas i följande program, som beräknar
en Taylor-utveckling för exponentialfunktionen (fungerar t.o.m. x-värdet 10). Observera, att subrutinen
TAYLOR anropar POWFAC inom samma modul. Modulen func kan också kompileras skilt för sig.
MODULE func
implicit none
contains
FUNCTION POWFAC (X,N)
IMPLICIT NONE
REAL :: POWFAC
REAL, INTENT(IN) :: X
INTEGER, INTENT(IN) :: N
INTEGER :: I
POWFAC = 1.
DO I = 1,N
POWFAC = POWFAC*X/REAL(I)
END DO
RETURN
END FUNCTION POWFAC
FUNCTION TAYLOR (X,N)
IMPLICIT NONE
REAL :: TAYLOR
INTEGER, INTENT(IN) :: N
REAL, INTENT(IN) :: X
INTEGER :: I
TAYLOR = 1.
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
12
DO
I=1,N
TAYLOR = TAYLOR + POWFAC(X,I)
END DO
RETURN
END FUNCTION TAYLOR
END MODULE func
PROGRAM tayltest
USE func
IMPLICIT NONE
INTEGER :: I
REAL :: X, Y, Y1
PRINT *, "Ange x: "
READ *, X
Y1 = 1.
DO I=1,30
Y = TAYLOR(X,I)
print *, i, y
IF (ABS(Y-Y1) <= EPSILON(Y)) EXIT
Y1 = Y
END DO
PRINT *, " Tayl = ", Y, " Diff = ", Y-Y1, " I = ", I
STOP
END PROGRAM tayltest
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
13
2.8. Inmatning och utskrift i Fortran
Vi har tidigare beskrivit vad man brukar kalla listorienterad inmatning och utskrivning med hjälp av READoch PRINT-satserna. Någon större kontroll av formatet får man dock inte på detta sätt. Dessutom kan vi
inte läsa och skriva datafiler (t.ex.), utan måste begränsa oss till dataterminalen.
En allmän inmatningsinstruktion kan ges i formen READ (enhet, format) datalista, där enhet anger en
logisk enhetsnummer (som kan vara ett heltalsuttryck), format anger på vilket sätt data skall läsas in, och
datalista är en lista på variabler som läses in. Den motsvarande allmänna utskriftsinstruktionen är WRITE
(enhet, format) datalista.
Istället för att ange en enhetsnummer, kan man använda en asterisk (*), t.ex. WRITE (*, 100) ...,
som anger utskrift på en terminal (instruktionen betyder i detta fall detsamma som PRINT 100, ...).
Formatspecifikationen kan anges på olika sätt. Ett sätt är att använda en satsnummer, instruktionen WRITE
(*, 100) I kan t.ex. efterföljas av en formatsats 100
FORMAT(1X,I4), som anger att fyra tecken
skall reserveras för heltalsvariabeln I. Denna formatsats kan placeras var som helst i programmet (eller
subrutinen). Ofta brukar man samla formatsatserna i slutet av programenheten (före END), eller genast
efter in- och utmatningssatserna, för att man inte skall glömma bort dem så lätt. Man kan också inkludera
formatsatsen i själva inmatnings- eller utskriftsinstruktionen.
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
14
I exemplet ovan skulle man t.ex. kunna skriva WRITE (*, ’(1X,I4)’) I eller mera explicit, WRITE (*,
FMT=’(1X,I4)’) I (observera apostroferna).
Vi skall nu studera mera i detalj de olika formatspecifikationerna. En formatspecifikation består i allmänhet
av en lista av beskrivningar åtskiljda av kommatecken, och omgivna av parenteser. För att beskriva utskrift
av heltal (t.ex.) används beteckningen kIm, som reserverar plats för k stycken heltal, som vart och ett har
plats för m tecken. Om k = 1, kan det utelämnas.
För att lämna mellanrum används beteckningen nX, där n anger antalet mellanrum. Om man skickar
utskriften till en skrivare, kommer oftast det första tecknet på raden inte att skrivas ut, och därför brukar
man inleda formatspecifikationen med 1X, såsom ’(1X,I4)’. En mera användbar formatspecifikation är
Tn, och de besläktade specifikationerna TRn och TLn, som gör det möjligt ange den position på raden, där
följande utskrift börjar. Specifikationen T5 anger sålunda, att följande tecken skall skrivas ut f.o.m. den
femte kolumnen, medan TR5 anger, att man skall flytta sig fem positioner framåt, innan följande utskrift
sker. Specifikationen TRn har således samma effekt som nX. Sålunda betyder t.ex.
PRINT ’(T3,I3,TR4,I5,T20,F8.3)’, A,B,C
att talet A skrivs med början i kolumn 3 (egentligen kolumn 2, om utskriften sker till radskrivare), sedan
överhoppas fyra kolumner, innan B skrivs ut, och till slut skrivs C ut f.o.m. kolumn 20.
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
15
Antag, att tre heltal I, J och K skrivs med satsen WRITE (*,100) I, J, K, och att formatsatsen är
100
FORMAT(1X,I4,1X,I5,I6). Om talen är I = 3, J = −31 och K = 2300, så kommer
utskriften att se ut på följande sätt:
3 -31 2300
(observera mellanrummen). Om man vill skriva ut talen på tre skilda rader, så måste man använda tre
skilda WRITE-satser:
WRITE (*,100) I
WRITE (*,100) J
WRITE (*,100) K
Resultatet av utskriften blir i detta fall
3
-31
2300
Mellan listan i formatbeskrivningen och datalistan råder en entydig motsvarighet. Datalistan läses från
vänster till höger. Om listan i formatbeskrivningen tar slut innan datalistan slutbehandlats, påbörjas automatiskt en ny rad. Med varje WRITE-sats skriver man ut en post (record). När datalistan tar slut, avslutas
behandlingen av formatbeskrivningen (av detta följer att alla heltal i exemplet skrivs ut i formatet I4).
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
16
Man kan också skriva ut talen på skilda rader på ett annat sätt, genom att använda specifikationen /:
WRITE (*, FMT=100) I,J,K
100 FORMAT (1X, I4/I5/I6)
Behandlingen av reella tal är något mer komplicerad. Formatbeskrivningen har i allmänhet formen kFm.n,
som anger utskrift av k stycken tal för vilka reserverats m tecken, varav n decimaler. Satsen PRINT
’(1X, F8.4)’, X anger sålunda, att talet X skrivs ut i kolumnerna 2-9 med fyra decimaler. Om t.ex.
X = −2.34567, så blir utskriften -2.3456. Observera, att ingen konversion av reella tal till heltal
och vice versa kan förekomma.
Antag att I = 3, J = −66, X = 45.789 och Z = −998.78 är fyra tal som skall skrivas ut med
satserna
99
WRITE (*, 99) I, X, J, Z
FORMAT (1X, I3, F8.3)
Eftersom formatlistan endast innehåller två specifikationer, kommer talen att skrivas ut på två rader:
3 45.789
-66-998.780
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
17
Om man vill skriva talen på samma rad, kan man upprepa formatbeskrivningen för talen på följande
sätt: FORMAT (1X, 2(I3,F8.3)), vilket är ekvivalent med FORMAT (1X, I3, F8.3, I3, F8.3).
Man kan också använda en upprepad formatbeskrivning för att skriva ut en rad med tecken på skärmen:
PRINT ’(1X, 60(’’*’’))’ (observera den dubbla apostrofen, som behövs eftersom formatbeskrivningen bör omges av apostrofer!). Om en matris är symmetrisk, brukar man ofta endast skriva ut den
undre triangeln. Detta kan göras med följande slinga:
DO
i=1,n
WRITE (*, ’(1X,10F8.3)’) (A(i,j) , j=1,i)
END DO
Med detta format kan man skriva högst tio matriselement per rad. Om n > 10, kommer längre rader att
delas upp på flere, eftersom datalistan i detta fall är längre än formatlistan.
Med hjälp av specifikationen / kan man skriva ut komplicerade utskrifter med en enda WRITE-sats, såsom
visas av följande exempel:
WRITE (6, FMT=200) x, y, x+y, x*y
200 FORMAT (1X//5X,"Utskriftsexempel"// &
1X, "Summan av", F8.3, " och ", F8.3, " är ", F9.3// &
1X, "Deras produkt är ", F15.4//)
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
18
Exempel på utskriften i detta fall är
Utskriftsexempel
Summan av
12.250 och
Deras produkt är
23.500 är
35.750
287.8750
För reella tal som uttryckes i exponentiell form finns ett särskilt format, som allmänt uttrycks kEm.n.
Liksom tidigare anger k antalet upprepningar, m är totalantalet tecken som reserveras för talet, och n är
antalet decimaler. När man räknar ut hur många tecken som behövs totalt, måste man komma ihåg att
reservera ett tecken för förtecknet, ett för decimalpunkten, ett för bokstaven E (som betyder ’exponent’)
samt ytterligare (minst) tre tecken för exponenten. Om vi t.ex. använder formatet E14.4, så uttrycks
talen 12.5689 · 1012 och −4.567 · 10−8 som
0.1256E+14 resp.
-0.4567E-07 (om datorn
normerar mantissan till ett tal mellan 0 och 1).
För att formatera teckensträngar används i Fortran ett särskilt format, som allmänt kan uttryckas kAn,
där k anger antalet upprepningar, och n är antalet tecken i strängen. Med hjälp av detta format kan man
skriva ut den tidigare omnämnda asteriskraden på ett annat sätt:
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
19
100
CHARACTER (1), PARAMETER :: star=’*’
PRINT 100,(star, I=1,60)
FORMAT(1X,80A1)
Observera även, att ett heltal endast kan skrivas ut med I-format, och ett reellt tal endast med F-format.
Om man försöker skriva ut heltal med F-format eller reella tal med I-format vet man inte vad som kan
hända.
Som ett mera konkret exempel på utskrift, skall vi studera ett program, som skriver ut en tabell.
PROGRAM trigtab
! Program som skriver ut en tabell över sinus och cosinus
IMPLICIT NONE
REAL :: x
REAL , PARAMETER :: pi=3.14159265
INTEGER :: i
PRINT ’(4X,A)’, "Sinus och cosinustabell"
PRINT ’(4X,23(’’-’’)/)’
PRINT ’(1X,A,4X,A,6X,A))’, "x(grader)","sin x", "cos x"
DO i=1,11
x = pi*REAL(I-1)/5.
PRINT ’(1X,I6,2X,2F11.6)’, 36*(I-1), SIN(X), COS(X)
END DO
END PROGRAM trigtab
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
20
Resultatet kommer att se ut såhär:
Sinus och cosinustabell
----------------------x(grader)
0
36
72
108
144
180
216
252
288
324
360
sin x
0.000000
0.587785
0.951057
0.951056
0.587785
0.000000
-0.587785
-0.951056
-0.951056
-0.587785
0.000000
cos x
1.000000
0.809017
0.309017
-0.309017
-0.809017
-1.000000
-0.809017
-0.309017
0.309017
0.809017
1.000000
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
21
Vi skall ytterligare se på ett annat exempel, som visar hur man kan skriva ut en multiplikationstabell med
relativt ”snygg” formatering. Programmet använder positionsformatering, och skriver ut tabellen som en
10 × 10-matris.
PROGRAM multi
! Ett program som skriver ut multiplikationstabellen
! 1-9 i snyggt format
IMPLICIT NONE
INTEGER :: X, Y
CHARACTER (1) :: NUM(9)
DO X = 1, 9
NUM(X) = ACHAR(X+48)
END DO
WRITE (*, FMT=100) (NUM(X), X=1,9)
100 FORMAT(T5,’*|’, 9(TR2,A))
WRITE (*, ’(T5,’’-+’’,27(’’-’’))’)
DO X = 1, 9
WRITE (*, 101) X, (X*Y, Y = 1, 9)
101 FORMAT (T5,I1,’|’,9(TR1,I2))
END DO
STOP
END PROGRAM multi
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
22
När programmet utföres, får man följande resultat:
*| 1 2 3 4 5 6 7 8 9
-+--------------------------1| 1 2 3 4 5 6 7 8 9
2| 2 4 6 8 10 12 14 16 18
3| 3 6 9 12 15 18 21 24 27
4| 4 8 12 16 20 24 28 32 36
5| 5 10 15 20 25 30 35 40 45
6| 6 12 18 24 30 36 42 48 54
7| 7 14 21 28 35 42 49 56 63
8| 8 16 24 32 40 48 56 64 72
9| 9 18 27 36 45 54 63 72 81
Samma formatbeskrivningar, som gäller för utskrift kan också användas för inmatning av data. Man måste
dock vara noggrann med att införa tal i rätt kolumn, eftersom de annars lätt tolkas fel.
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
23
Om vi t.ex. skall läsa in två tal med instruktionerna
10
READ (*, 10) I,J
FORMAT (2I4)
och skriver de två talen, t.ex. 15 och 24 , så att det första av dem upptar kolumnerna 4-5 och det andra
talet kolumnerna 8-9, så får vi I = 1 och J = 52, vilket knappast var meningen (”mellanrum ignoreras i
numeriska fält”).
En liknande flexibel tolkning gäller också för läsning av reella tal. Om vi t.ex. läser raden 123 456
(observera: två mellanrum före vartdera talet) med satsen READ ’(I5, F5.2)’, I,X så blir tolkningen
I = 123, X = 4.56, men om vi istället använder satsen READ ’(I4,F6.2)’,I,X så blir tolkningen
I = 12, X = 34.56.
Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009
JJ J I II ×
24