2.8. Inmatning och utskrift i Fortran

forts. p˚a f¨oreg˚aende f¨orel¨asning:

Vi har redan n¨amnt att det finns inbyggda funktioner i Fortran, och har ocks˚a redan anv¨ant n˚agra av de matematiska funktionerna, s˚asom ABS, SQRT och SIN. Vi skall nu studera dem i litet mera detalj.

Inbyggda funktioner beh¨over i allm¨anhet inte typdeklareras, eftersom de ¨ar k¨anda av systemet, och typen framg˚ar oftast av argumentet. D¨arf¨or beh¨over de inte heller n˚agot explicit gr¨anssnitt. I detta sammanhang kan n¨amnas, att m˚anga av de inbyggda funktionerna f¨orr anv¨andes med specifika namn, som var beroende av argumentets typ. Numera rekommenderas att man anv¨ander det s.k. generiska namnet, som ¨ar oberoende av argumentets typ. Som exempel kan n¨amnas ABS-funktionen. Om argumentet ¨ar heltaligt, kan man anv¨anda det specifika namnet IABS, och om argumentet ¨ar komplext, s˚a kan man anv¨anda det specifika namnet CABS, men enklast kommer man undan, om anv¨ander det generiska namnet ABS, som kan anv¨andas oberoende av argumentets typ. I Fortran 90 ¨ar det ocks˚a m¨ojligt att deklarera egna generiska funktioner med l¨ampliga gr¨anssnitt. N˚agra funktioner har flera argument, och de b¨or i s˚afall vara av samma typ (t.ex.

b˚ada heltaliga, eller b˚ada reella).

Fortran 90 har ett stort antal inbyggda funktioner. Vi skall h¨arnedan ge en f¨orteckning ¨over de generiska namnen f¨or de vanligaste av dem j¨amte en kort f¨orklaring av deras anv¨andning.

Generiskt namn Betydelse

ABS(X) Absoluta v¨ardet av X

ACOS(X) Arcus cosinus(X), den vinkel 0 ≤ a ≤ π f¨or vilken cos(a) = X ADJUSTL(A) V¨ansterjusterar str¨angen A

ADJUSTR(A) H¨ogerjusterar str¨angen A

AIMAG(Z) Imagin¨ara delen av det komplexa talet Z

ASIN(X) Arcus sinus(X), den vinkel −π/2 ≤ a ≤ π/2 f¨or vilken sin(a) = X

ATAN(X) Arcus tangenten (X), den vinkel −π/2 ≤ a ≤ π/2 f¨or vilken tan(a) = X ATAN2(Y,X) Arcus tangenten (X), den vinkel −π ≤ a ≤ π f¨or vilken tan(a) = Y /X CEILING(X) Det minsta heltalet, som ¨ar ≥ X

CHAR(I) Tecknet, vars ASCII-kod ¨ar I

CMPLX(X,Y) Bildar det komplexa talet X + iY CONJG(Z) Konjugattalet f¨or det komplexa talet Z

COS(X) Cosinus (X)

COSH(X) Cosinus hyperbolicus (X), (e^X + e^−X)/2 DBLE(X) Konverterar X till dubbel precision

DOT PRODUCT(U,V) Skal¨arprodukten av vektorerna u och v

EPSILON(X) Ett mycket litet tal, j¨amf¨ort med 1 (ca 10⁻⁷) EXP(X) Exponentialfunktionen e^x

FLOOR(X) St¨orsta heltalet ≤ X

FRACTION(X) Br˚aktalsdelen av talet X

HUGE(X) Det st¨orsta talet som kan framst¨allas (ca 10³⁸) IAND(i,j) Bitvis logiskt AND av i och j

IBCLR(i,n) Nollst¨aller biten n i heltalet i IBSET(i,n) S¨atter bit n till 1 i heltalet i ICHAR(A) ASCII-koden f¨or tecknet A

INT(X) Avkortning av ett reellt tal till heltal IOR(i,j) Bitvis OR av heltalen i och j

LEN(A) L¨angden av str¨angen A

LEN TRIM(A) L¨angden av str¨angen A utan blanka tecken p˚a slutet LOG(X) Naturliga logaritmen av X: ln x

LOG10(X) Briggska logaritmen av X: log x

MATMUL(A,B) Matrisprodukten av matriserna A och B MAX(X,Y,...) Maximiv¨ardet av X, Y, . . .

MIN(X,Y,...) Minimiv¨ardet av X, Y, . . .

MOD(X,Y) Resten av X/Y , dvs X - FLOOR(X/Y)*Y (X reellt) NINT(X) Heltalet n¨armast X: INT(X + SIGN(0.5,X))

NOT(I) Ger logiska komplementet av argumentet I RANDOM NUMBER(X) Subrutin, som ber¨aknar pseudoslumptal

RANDOM SEED(size, put,get) Anv¨ands f¨or att starta RANDOM NUMBER REAL(I) Konversion av ett heltal I till ett reellt tal

RESHAPE(X,S) Funktion f¨or att konstruera en matris fr˚an en vektor X

SCALE(X,I) Multiplicerar X med 2^I

SIGN(X,Y) Utbyte av tecken, dvs (Y:s tecken)*ABS(X)

SIN(X) Sinus (X)

SINH(X) Sinus hyperbolicus (X), (e^X − e^−X)/2

SIZE(A) Ger antalet element i matrisen A

SQRT(X) Kvadratroten ur X

SUM(A,n) Summan av elementen i matrisen A l¨angs dimensionen n

TAN(X) Tangenten av X

TANH(X) Tangens hyperbolica, (e^X − e^−X)/(e^X + e^−X) TINY(X) Det minsta tal som kan representeras (ca 10⁻³⁸)

TRANSPOSE(A) Transponering av matrisen A

TRIM(A) Stryker blanka sluttecken fr˚an str¨angen A

Som exempel p˚a anv¨andningen av matematiska funktioner f¨or heltalsaritmetik skall vi studera ett program, som s¨oker upp alla primtal mellan 1 och 100. Metoden baserar sig p˚a att ett udda heltal n ¨ar ett primtal, ifall det inte ¨ar j¨amnt delbart med n˚agot udda heltal mellan 3 och √

n. Vi ser ocks˚a ett exempel p˚a, hur man kan namnge DO-slingor f¨or att flytta kontrollen fr˚an den inre till den yttre slingan med CYCLE.

PROGRAM Primtal

! Program f¨or att upps¨oka 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 ¨ar ett primtal!

PRINT *, n END DO yttre STOP

END PROGRAM Primtal

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).

Andam˚¨ alet med en modul ¨ar att g¨ora de variabler, som d¨ar deklareras tillg¨angliga f¨or andra programen- heter. Modulerna m¨ojligg¨or allts˚a global tillg¨anglighet f¨or variabler och konstanter, och kan s˚alunda ers¨atta COMMON-blocken i FORTRAN 77.

F¨or att kunna anv¨anda variablerna i en modul i en subrutin, anv¨ands USE-satsen, som b¨or st˚a i b¨orjan av det anropande programmet. Som ett exempel skall vi studera en enkel modul, som definierar n˚agra konstanter och variabler, och hur denna modul anv¨ands i en subrutin. Antag, att modulen ser ut s˚a h¨ar:

MODULE testdata IMPLICIT NONE SAVE

! Konstanter

REAL, PARAMETER :: c=2.9979E8, pi=3.14159

! Variabler

REAL :: data_1, data_2, data_3 END MODULE testdata

En subrutin, som anv¨ander dessa data skulle kunna b¨orja s˚ah¨ar:

SUBROUTINE sub USE testdata IMPLICIT NONE

( andra deklarationer) ...

( utf¨orbara satser) ...

END SUBROUTINE sub

Som man l¨att inser, ¨ar moduler speciellt viktiga i stora program med m˚anga subrutiner, som ofta behandlar samma data. Anv¨andningen av moduler g¨or argumentlistorna kortare. Observera anv¨andningen av SAVE- satsen i modulen. Det ¨ar f¨or att data med s¨akerhet skall bevaras under programk¨orningen.

Som ytterligare ett exempel skall vi skriva om programmet som ber¨aknar summan av tv˚a tal genom att anv¨anda en modul, som g¨or variablerna globalt tillg¨angliga.

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

Satsen USE kan ocks˚a anv¨andas i en annan modul, varigenom deklarationerna i den f¨orsta modulen blir tillg¨angliga i den andra, och en subrutin som anv¨ander den andra modulen, f˚ar d¨armed ocks˚a automatiskt tillg˚ang till den andra modulens data. Detta belyses av nedanst˚aende 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

Moduler kan ocks˚a anv¨anda f¨or att g¨ora det bekv¨amare att anv¨anda explicita gr¨anssnitt, vilket visas av f¨oljande 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

Man kan ocks˚a inkapsla procedurer i en modul med hj¨alp av CONTAINS-satsen. Med hj¨alp av USE-satsen kan man sedan g¨ora dem tillg¨angliga i ett program som anropar dem, och beh¨over d˚a inte anv¨anda ett explicit gr¨anssnitt. Besl¨aktade rutiner kan inneslutas i samma modul, och var och en av dem har ett explicit gr¨anssnitt till de andra procedurerna i modulen. Programexemplet ovan skulle allts˚a ocks˚a 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

Ett mera konkret exempel p˚a anv¨andningen av modulprocedurer visas i f¨oljande program, som ber¨aknar en Taylor-utveckling f¨or exponentialfunktionen (fungerar t.o.m. x-v¨ardet 10). Observera, att subrutinen TAYLOR anropar POWFAC inom samma modul. Modulen func kan ocks˚a kompileras skilt f¨or 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.

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

2.8. Inmatning och utskrift i Fortran

Vi har tidigare beskrivit vad man brukar kalla listorienterad inmatning och utskrivning med hj¨alp av READ- och PRINT-satserna. N˚agon st¨orre kontroll av formatet f˚ar man dock inte p˚a detta s¨att. Dessutom kan vi inte l¨asa och skriva datafiler (t.ex.), utan m˚aste begr¨ansa oss till dataterminalen.

En allm¨an inmatningsinstruktion kan ges i formen READ (enhet, format) datalista, d¨ar enhet anger en logisk enhetsnummer (som kan vara ett heltalsuttryck), format anger p˚a vilket s¨att data skall l¨asas in, och datalista ¨ar en lista p˚a variabler som l¨ases in. Den motsvarande allm¨anna utskriftsinstruktionen ¨ar WRITE (enhet, format) datalista.

Ist¨allet f¨or att ange en enhetsnummer, kan man anv¨anda en asterisk (*), t.ex. WRITE (*, 100) ..., som anger utskrift p˚a en terminal (instruktionen betyder i detta fall detsamma som PRINT 100, ...).

Formatspecifikationen kan anges p˚a olika s¨att. Ett s¨att ¨ar att anv¨anda en satsnummer, instruktionen WRITE (*, 100) I kan t.ex. efterf¨oljas av en formatsats 100 FORMAT(1X,I4), som anger att fyra tecken skall reserveras f¨or heltalsvariabeln I. Denna formatsats kan placeras var som helst i programmet (eller subrutinen). Ofta brukar man samla formatsatserna i slutet av programenheten (f¨ore END), eller genast efter in- och utmatningssatserna, f¨or att man inte skall gl¨omma bort dem s˚a l¨att. Man kan ocks˚a inkludera formatsatsen i sj¨alva inmatnings- eller utskriftsinstruktionen.

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˚ar i allm¨anhet av en lista av beskrivningar ˚atskiljda av kommatecken, och omgivna av parenteser. F¨or att beskriva utskrift av heltal (t.ex.) anv¨ands beteckningen kIm, som reserverar plats f¨or k stycken heltal, som vart och ett har plats f¨or m tecken. Om k = 1, kan det utel¨amnas.

F¨or att l¨amna mellanrum anv¨ands beteckningen nX, d¨ar n anger antalet mellanrum. Om man skickar utskriften till en skrivare, kommer oftast det f¨orsta tecknet p˚a raden inte att skrivas ut, och d¨arf¨or brukar man inleda formatspecifikationen med 1X, s˚asom ’(1X,I4)’. En mera anv¨andbar formatspecifikation ¨ar Tn, och de besl¨aktade specifikationerna TRn och TLn, som g¨or det m¨ojligt ange den position p˚a raden, d¨ar f¨oljande utskrift b¨orjar. Specifikationen T5 anger s˚alunda, att f¨oljande tecken skall skrivas ut f.o.m. den femte kolumnen, medan TR5 anger, att man skall flytta sig fem positioner fram˚at, innan f¨oljande utskrift sker. Specifikationen TRn har s˚aledes samma effekt som nX. S˚alunda betyder t.ex.

PRINT ’(T3,I3,TR4,I5,T20,F8.3)’, A,B,C

att talet A skrivs med b¨orjan i kolumn 3 (egentligen kolumn 2, om utskriften sker till radskrivare), sedan

¨overhoppas fyra kolumner, innan B skrivs ut, och till slut skrivs C ut f.o.m. kolumn 20.

Antag, att tre heltal I, J och K skrivs med satsen WRITE (*,100) I, J, K, och att formatsatsen ¨ar 100 FORMAT(1X,I4,1X,I5,I6). Om talen ¨ar I = 3, J = −31 och K = 2300, s˚a kommer utskriften att se ut p˚a f¨oljande s¨att:

3 -31 2300

(observera mellanrummen). Om man vill skriva ut talen p˚a tre skilda rader, s˚a m˚aste man anv¨anda 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˚ader en entydig motsvarighet. Datalistan l¨ases fr˚an v¨anster till h¨oger. Om listan i formatbeskrivningen tar slut innan datalistan slutbehandlats, p˚ab¨orjas au- tomatiskt en ny rad. Med varje WRITE-sats skriver man ut en post (record). N¨ar datalistan tar slut, avslutas behandlingen av formatbeskrivningen (av detta f¨oljer att alla heltal i exemplet skrivs ut i formatet I4).

Man kan ocks˚a skriva ut talen p˚a skilda rader p˚a ett annat s¨att, genom att anv¨anda specifikationen /:

WRITE (*, FMT=100) I,J,K 100 FORMAT (1X, I4/I5/I6)

Behandlingen av reella tal ¨ar n˚agot mer komplicerad. Formatbeskrivningen har i allm¨anhet formen kFm.n, som anger utskrift av k stycken tal f¨or vilka reserverats m tecken, varav n decimaler. Satsen PRINT

’(1X, F8.4)’, X anger s˚alunda, att talet X skrivs ut i kolumnerna 2-9 med fyra decimaler. Om t.ex.

X = −2.34567, s˚a blir utskriften -2.3456. Observera, att ingen konversion av reella tal till heltal och vice versa kan f¨orekomma.

Antag att I = 3, J = −66, X = 45.789 och Z = −998.78 ¨ar fyra tal som skall skrivas ut med satserna

WRITE (*, 99) I, X, J, Z 99 FORMAT (1X, I3, F8.3)

Eftersom formatlistan endast inneh˚aller tv˚a specifikationer, kommer talen att skrivas ut p˚a tv˚a rader:

3 45.789 -66-998.780

Om man vill skriva talen p˚a samma rad, kan man upprepa formatbeskrivningen f¨or talen p˚a f¨oljande s¨att: FORMAT (1X, 2(I3,F8.3)), vilket ¨ar ekvivalent med FORMAT (1X, I3, F8.3, I3, F8.3).

Man kan ocks˚a anv¨anda en upprepad formatbeskrivning f¨or att skriva ut en rad med tecken p˚a sk¨armen:

PRINT ’(1X, 60(’’*’’))’ (observera den dubbla apostrofen, som beh¨ovs eftersom formatbeskriv- ningen b¨or omges av apostrofer!). Om en matris ¨ar symmetrisk, brukar man ofta endast skriva ut den undre triangeln. Detta kan g¨oras med f¨oljande slinga:

DO i=1,n

WRITE (*, ’(1X,10F8.3)’) (A(i,j) , j=1,i) END DO

Med detta format kan man skriva h¨ogst tio matriselement per rad. Om n > 10, kommer l¨angre rader att delas upp p˚a flere, eftersom datalistan i detta fall ¨ar l¨angre ¨an formatlistan.

Med hj¨alp av specifikationen / kan man skriva ut komplicerade utskrifter med en enda WRITE-sats, s˚asom visas av f¨oljande exempel:

WRITE (6, FMT=200) x, y, x+y, x*y

200 FORMAT (1X//5X,"Utskriftsexempel"// &

1X, "Summan av", F8.3, " och ", F8.3, " ¨ar ", F9.3// &

1X, "Deras produkt ¨ar ", F15.4//)

Exempel p˚a utskriften i detta fall ¨ar Utskriftsexempel

Summan av 12.250 och 23.500 ¨ar 35.750 Deras produkt ¨ar 287.8750

F¨or reella tal som uttryckes i exponentiell form finns ett s¨arskilt format, som allm¨ant uttrycks kEm.n.

Liksom tidigare anger k antalet upprepningar, m ¨ar totalantalet tecken som reserveras f¨or talet, och n ¨ar antalet decimaler. N¨ar man r¨aknar ut hur m˚anga tecken som beh¨ovs totalt, m˚aste man komma ih˚ag att reservera ett tecken f¨or f¨ortecknet, ett f¨or decimalpunkten, ett f¨or bokstaven E (som betyder ’exponent’) samt ytterligare (minst) tre tecken f¨or exponenten. Om vi t.ex. anv¨ander formatet E14.4, s˚a uttrycks talen 12.5689 · 10¹² och −4.567 · 10⁻⁸ som 0.1256E+14 resp. -0.4567E-07 (om datorn normerar mantissan till ett tal mellan 0 och 1).

F¨or att formatera teckenstr¨angar anv¨ands i Fortran ett s¨arskilt format, som allm¨ant kan uttryckas kAn, d¨ar k anger antalet upprepningar, och n ¨ar antalet tecken i str¨angen. Med hj¨alp av detta format kan man skriva ut den tidigare omn¨amnda asteriskraden p˚a ett annat s¨att:

CHARACTER (1), PARAMETER :: star=’*’

PRINT 100,(star, I=1,60) 100 FORMAT(1X,80A1)

Observera ¨aven, att ett heltal endast kan skrivas ut med I-format, och ett reellt tal endast med F-format.

Om man f¨ors¨oker skriva ut heltal med F-format eller reella tal med I-format vet man inte vad som kan h¨anda.

Som ett mera konkret exempel p˚a utskrift, skall vi studera ett program, som skriver ut en tabell.

PROGRAM trigtab

! Program som skriver ut en tabell ¨over 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

Resultatet kommer att se ut s˚ah¨ar:

Sinus och cosinustabell ---

x(grader) sin x cos x

0 0.000000 1.000000

36 0.587785 0.809017

72 0.951057 0.309017

108 0.951056 -0.309017 144 0.587785 -0.809017 180 0.000000 -1.000000 216 -0.587785 -0.809017 252 -0.951056 -0.309017 288 -0.951056 0.309017 324 -0.587785 0.809017 360 0.000000 1.000000

Vi skall ytterligare se p˚a ett annat exempel, som visar hur man kan skriva ut en multiplikationstabell med relativt ”snygg” formatering. Programmet anv¨ander 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

N¨ar programmet utf¨ores, f˚ar man f¨oljande 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¨aller f¨or utskrift kan ocks˚a anv¨andas f¨or inmatning av data. Man m˚aste dock vara noggrann med att inf¨ora tal i r¨att kolumn, eftersom de annars l¨att tolkas fel.

Om vi t.ex. skall l¨asa in tv˚a tal med instruktionerna READ (*, 10) I,J

10 FORMAT (2I4)

och skriver de tv˚a talen, t.ex. 15 och 24 , s˚a att det f¨orsta av dem upptar kolumnerna 4-5 och det andra talet kolumnerna 8-9, s˚a f˚ar vi I = 1 och J = 52, vilket knappast var meningen (”mellanrum ignoreras i numeriska f¨alt”).

En liknande flexibel tolkning g¨aller ocks˚a f¨or l¨asning av reella tal. Om vi t.ex. l¨aser raden 123 456 (observera: tv˚a mellanrum f¨ore vartdera talet) med satsen READ ’(I5, F5.2)’, I,X s˚a blir tolkningen I = 123, X = 4.56, men om vi ist¨allet anv¨ander satsen READ ’(I4,F6.2)’,I,X s˚a blir tolkningen I = 12, X = 34.56.