LibroFortran95 2003 (OtroIdoma) (339s)

For t r an 95/2003
Juha Haataja, Jussi Rahola ja Juha Ruokolainen
FORTRAN95_2003.indd 3
23.4.2007 12:48:23
Fortran 95/2003
Juha Haataja
Jussi Rahola
Juha Ruokolainen
Tieteen tietotekniikan keskus CSC
Tmn teoksen tekijnoikeudet kuuluvat CSC Tieteellinen laskenta Oy:lle. Teoksen tai osia siit voi kopioida ja tulostaa vapaasti henkilkohtaiseen kyttn sek Suomen yliopistojen ja korkeakoulujen kurssikyttn edellytten, ett kopioon tai tulosteeseen liitetn tm ilmoitus teoksen tekijst ja tekijnoikeuksista. Teosta ei saa myyd tai sisllytt osaksi muita teoksia ilman
CSC:n lupaa.
c Juha Haataja, Jussi Rahola, Juha Ruokolainen ja

CSC Tieteellinen laskenta Oy
2007
Neljs uudistettu painos
ISBN 978-952-5520-23-1 (nid.)
ISBN 978-952-5520-24-8 (pdf)
http://www.csc.fi/csc/julkaisut/oppaat
Fortran 95/2003
Esipuhe
Fortran on trkein ja kytetyin ohjelmointikieli numeerisessa laskennassa.
Fortran 2003 on kielen uusin standardi. Koska uuden standardin kaikkia
piirteit ymmrtvi kntji ei viel ole markkinoilla, keskitymme uuden
standardin siihen osajoukkoon, joka sisltyy Fortran 95 -standardiin.
Fortran 95 ja sit edeltnyt Fortran 90 -standardi kuvaavat aikaisempia Fortranin versioita monipuolisemman ohjelmointikielen, joka sislt modernit
ohjaus- ja tietorakenteet. Koska Fortran koki monilta osin perusteellisen
muodonmuutoksen, on varsin aiheellista esitell Fortran 95 kokonaan uutena ohjelmointikielen. Tss teoksessa on ksitelty erillisess luvussa siirtymist FORTRAN 77:st uuteen standardiin. kaikkia ominaisuuksia, vaan
ppaino on trkeimmiksi katsomillamme piirteill. Vanha Fortran-kielen
standardi (FORTRAN 77) muodostaa Fortran 95:n osajoukon, joten kieli on
yhteensopiva vanhojenkin koodien kanssa.
Lukijalta ei edellytet Fortran-kielen aiempaa tuntemusta, vaikkakin ohjelmoinnin perusksitteet on syyt tuntea. Fortran-kntjn kyttesimerkit
on esitetty Unix-ympristss, mutta Unixiin liittyvt yksityiskohdat on pyritty minimoimaan.
Tmn teoksen ensimminen painos ilmestyi vuonna 1996 ja kertoi aiemmasta Fortran 90 -standardista. Tss kirjassa kerrotaan posin Fortran 95
-standardista eli uuden Fortran 2003 -standardin osajoukosta. Erillisess luvussa on tiivis kuvaus Fortran 2003:n uusista piirteist. Lisksi esittelemme
lyhyesti rinnakkaisohjelmointia High Performance Fortran -kielell (HPF) ja
OpenMP:ll.
Teoksen syntyyn ovat vaikuttaneet kokemuksemme tieteellisen ja teknisen
laskennan asiantuntijatehtviss. Olemme valinneet kyttmmme nkkulman ja esitystavan tieteen tietotekniikan keskuksen CSC:n asiakasprojekteista kertyneiden kokemusten perusteella. Oma vaikutuksensa teokseen on
ollut aiemmin tuottamistamme kursseista ja julkaisuista saadulla palautteella. Suurimman osan tekstist on kirjoittanut Juha Haataja, joka mys
toimitti kirjan painokuntoon.
Kiitmme kaikkia kirjan sisltn vaikuttaneita tytovereitamme. Janne
Kontkanen antoi hyvi kommentteja oppikirjan ensimmisest raakaversiosta. Yrj Leino, Esko Jrvinen, Jari Jrvinen ja Peter Rback oikolukivat
teosta, mist heille kiitokset. Lisksi Jukka Korpela, Raija Kukkonen ja Markku Lindroos TKK:n atk-keskuksesta antoivat palautetta oppikirjan sisllst
Fortran 95/2003
ja esitystavasta. Erityisesti Jukka Korpelan kommentit ja parannusehdotukset auttoivat selkeyttmn teoksen sislt.
HPF: ksittelev luku perustuu Jussi Heikosen ja Janne Kontkasen kirjoittamaan artikkeliin. OpenMP:n esittely perustuu Jussi Heikosen kirjoittamaan artikkeliin. Kari Vasko osallistui Fortran 2003: esittelevn tekstin
aiemman version kirjoittamiseen. Olemme ottaneet mys huomioon CSC:n
jrjestmilt Fortran-kursseilta tulleen palautteen.
Toista painosta oikolukivat Tiina Kupila-Rantala, Yrj Leino ja Ville Savolainen. Kolmanteen painokseen listtiin ja laajennettiin muutamia harjoitustehtvi, ja samalla erit kirjan esimerkkej muokattiin numeerisesti stabiilimmiksi. Neljnness painoksessa keskitytn Fortran 95:een ja hahmotellaan uuden Fortran 2003:n sislt. Samalla joitakin virheit on korjattu
ja teksti stilisoitu. Erityiset kiitoksemme ansaitsee Robert Pich, jonka jrjestm Fortran-kurssi TTKK:ssa tuotti runsaasti palautetta ja korjausehdotuksia. Lisksi Janne Ignatius, Jussi Rahola ja Satu Tissari antoivat arvokasta
palautetta teoksen kolmatta painosta valmisteltaessa.
Otamme mielellmme vastaan kaikki thn kirjaan liittyvt kommentit. Ne
voi osoittaa Juha Haatajalle shkpostiosoitteeseen Juha.Haataja@csc.fi.
Toivotamme teoksen lukijoille lytmisen iloa sek antoisia hetki Fortranin
parissa.
Espoossa 24.4.2007
Tekijt
Sislt
Sislt
Esipuhe
Teoksen sislt ja merkinnt

1.1
Oppikirjan sisllst . . . . . . . . . . . . . . . . . . . . . . . . .
1.2
Kytetyt merkinnt ja esimerkkiohjelma . . . . . . . . . . . .
1.3
Listietoja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
12
13
14
Ohjelmoinnin perusksitteet
2.1
Mihin tarvitaan ohjelmointia . . . .
2.2
Tietokoneet ja ohjelmointi . . . . .
2.3
Mit tarkoitetaan tietokoneella . .
2.4
Ohjelmoinnin eri vaiheet . . . . . .
2.5
Ohjelman kntminen ja linkitys
2.6
Yhteenveto . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
16
16
17
17
18
19
21
Johdatus ohjelmointiin Fortran 95:ll

3.1
Fortran-kielen merkitys . . . . . . . . . .
3.2
Fortran 95:n trkeimmt uudet piirteet
3.3
Miksi Fortran-kielt kannattaa kytt .
3.4
Fortran-ohjelman perusrakenne . . . . .
3.5
Tunnusten nimeminen . . . . . . . . . .
3.6
Vakiot ja peruslaskutoimitukset . . . .
3.7
Muuttujat . . . . . . . . . . . . . . . . . .
3.8
Muuttujien tyypit . . . . . . . . . . . . . .
3.9
Sijoituslauseet . . . . . . . . . . . . . . .
3.10 Omien funktioiden mrittely ja kytt
3.11 Toistorakenteet . . . . . . . . . . . . . . .
3.12 Taulukot ja rakenteiset tyypit . . . . . .
3.13 Tulostuksen muotoilu . . . . . . . . . . .
3.14 Esimerkki: asuntolainan lyhennykset .
3.15 Ehtolauseet . . . . . . . . . . . . . . . . .
3.16 Esimerkki: simulointitehtv . . . . . . .
3.17 Fortran-kielen moduulit . . . . . . . . . .
3.18 Listietoja . . . . . . . . . . . . . . . . . .
3.19 Yhteenveto . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
23
23
24
25
25
26
27
28
29
29
30
32
33
35
35
37
38
40
42
42
Ohjelman perusrakenne
4.1
Lhdekoodin muoto . . . . . . . . . . . . . . . . . . . . . . . . .
4.2
Fortranin merkkivalikoima . . . . . . . . . . . . . . . . . . . . .
4.3
Muuttujien ja vakioiden nimet . . . . . . . . . . . . . . . . . . .
44
44
45
46
.
.
.
.
.
.
.
.
.
.
.
.
Fortran 95/2003
4.4
4.5
4.6
5
Ohjelmakoodin lauseiden jrjestys . . . . . . . . . . . . . . . .

INCLUDE-lause ja moduulit . . . . . . . . . . . . . . . . . . . . .
Yhteenveto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
48
49
Perustyypit
5.1
Perustyypit ja vakiot . . . . . . . . . .
5.2
Muuttujien mrittely . . . . . . . . .
5.3
Nimetyt vakiot . . . . . . . . . . . . .
5.4
IMPLICIT NONE ja alkukirjainsnt
5.5
Perustyyppien lajimreet . . . . . .
5.6
Esimerkki: sarjan summa . . . . . . .
5.7
Yhteenveto . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
51
51
53
54
55
56
60
63
Lausekkeet ja sijoituslauseet
6.1
Aritmeettiset lausekkeet . . . . . . .
6.2
Numeeriset standardifunktiot . . . .
6.3
Merkkijonolausekkeet . . . . . . . . .
6.4
Merkkitiedon ksittelyfunktioita . .
6.5
Merkkitieto ja taulukot . . . . . . . .
6.6
Loogiset lausekkeet . . . . . . . . . .
6.7
Esimerkkej loogisista lausekkeista
6.8
Merkkijonojen vertailu . . . . . . . .
6.9
Esimerkki: merkkijonojen lajittelu .
6.10 Sijoituslauseet ja laskentajrjestys .
6.11 Funktioiden sivuvaikutukset . . . . .
6.12 Operaattorien sidontajrjestys . . .
6.13 Yhteenveto . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
67
67
69
73
74
75
76
77
78
80
81
83
83
83
Ohjausrakenteet
7.1
Mihin tarvitsemme ohjausrakenteita . . . . .
7.2
Ehdollinen suoritus: IF-rakenne . . . . . . . .
7.3
Tapausten ksittely: SELECT CASE -rakenne
7.4
Toisto: DO-rakenne . . . . . . . . . . . . . . .
7.5
Esimerkki: Euklideen algoritmi . . . . . . . .
7.6
Poikkeusten ksittely . . . . . . . . . . . . . .
7.7
Hyppylause: GOTO-lause . . . . . . . . . . . .
7.8
Tiedonsiirron erikoistilanteet . . . . . . . . .
7.9
Yhteenveto . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
86
86
86
88
90
93
94
95
95
96
Funktiot ja aliohjelmat
8.1
Tehtvn jakaminen osiin . . . . . . . . . . . . . . . . .
8.2
Proseduurit, funktiot ja aliohjelmat . . . . . . . . . . .
8.3
Mihin proseduureja kytetn . . . . . . . . . . . . . . .
8.4
Funktioiden mrittely ja kytt . . . . . . . . . . . . .
8.5
Funktion otsikkolauseen muodot . . . . . . . . . . . . .
8.6
Funktion sivuvaikutukset . . . . . . . . . . . . . . . . . .
8.7
Aliohjelmien mrittely ja kytt . . . . . . . . . . . . .
8.8
Todellisten ja muodollisten argumenttien vastaavuus
8.9
Tiedon vlittminen proseduureihin . . . . . . . . . . .
8.10 Paikallisten muuttujien silyminen . . . . . . . . . . . .
8.11 Sisiset ja ulkoiset proseduurit . . . . . . . . . . . . . .
8.12 Rekursio . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
99
99
100
100
100
102
103
104
105
106
107
108
111
Sislt
8.13
8.14
8.15
8.16
8.17
8.18
8.19
8.20
8.21
8.22
Proseduurit argumentteina . . . . . . . . . . . . .
PURE-mre . . . . . . . . . . . . . . . . . . . . . .
ELEMENTAL-mre . . . . . . . . . . . . . . . . . .
Kutsumuodon mrittely . . . . . . . . . . . . . .
Esimerkki: NAG-aliohjelmakirjaston kytt . . .
Valinnaiset ja avainsana-argumentit . . . . . . .
Esimerkki: keskiarvon laskeminen . . . . . . . .
Milloin tarvitsemme kutsumuodon mrittely
Nkyvyysalueet . . . . . . . . . . . . . . . . . . . .
Yhteenveto . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
113
115
115
116
117
118
118
121
121
123
Moduulit ja operaattorit
9.1
Modulaarinen ohjelmointi . . . . . . . . . . . . .
9.2
Ohjelmayksikkjen vliset suhteet . . . . . . . .
9.3
Esimerkki: vakioiden mrittely . . . . . . . . . .
9.4
Esimerkki: pituusyksikkjen muunnokset . . .
9.5
Moduulin kyttminen toisista moduuleista . .
9.6
Julkisuus ja yksityisyys . . . . . . . . . . . . . . .
9.7
USE-lauseen eri kytttavat . . . . . . . . . . . .
9.8
Esimerkki: muunnosohjelma . . . . . . . . . . . .
9.9
Esimerkki: nollakohdan haku . . . . . . . . . . .
9.10 Moduulissa mritellyt globaalit muuttujat . .
9.11 Esimerkki: normaalijakautuneet satunnaisluvut
9.12 Geneeriset proseduurit . . . . . . . . . . . . . . .
9.13 Operaattoreiden mrittely . . . . . . . . . . . .
9.14 Yhteenveto operaattoreiden mrittelyst . . .
9.15 Funktioiden ja operaattorien kytttavat . . . .
9.16 Muita moduulien kyttmahdollisuuksia . . . .
9.17 Yhteenveto . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
126
126
127
128
128
131
131
133
134
135
137
138
140
142
147
147
148
148
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
152
152
155
158
159
159
161
11 Taulukot ja osoitinmuuttujat
11.1 Taulukoiden mrittely ja kytt . . . . . . . . . .
11.2 Taulukon alkioiden ksittely . . . . . . . . . . . . .
11.3 Taulukkoalustin . . . . . . . . . . . . . . . . . . . .
11.4 Taulukon alkioiden jrjestys . . . . . . . . . . . . .
11.5 Esimerkki: funktion arvojen talletus taulukkoon
11.6 Taulukoiden vlitys aliohjelmiin . . . . . . . . . .
11.7 Taulukkoarvoiset funktiot . . . . . . . . . . . . . .
11.8 Taulukkojen ksittely kokonaisuuksina . . . . . .
11.9 Taulukkojen ksittely standardifunktioilla . . . .
11.10 FORALL-rakenne . . . . . . . . . . . . . . . . . . . .
11.11 Dynaaminen muistinvaraus . . . . . . . . . . . . .
11.12 Esimerkki: Erastotheneen seula . . . . . . . . . . .
11.13 Osoitinmuuttujat . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
164
164
166
168
169
169
170
173
174
174
177
178
182
183
10 Rakenteiset tietotyypit
10.1 Rakenteisten tyyppien mrittely . . . . . .
10.2 Esimerkki: vektorilaskentamoduuli . . . . .
10.3 NULL-funktio . . . . . . . . . . . . . . . . . .
10.4 Julkisuus ja yksityisyys . . . . . . . . . . . .
10.5 Esimerkki: vektorimoduulin jatkokehittely
10.6 Yhteenveto . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
Fortran 95/2003
11.14 Esimerkki: listarakenne . . . . . . . . . . . . . . . . . . . . . . . 187

11.15 Yhteenveto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
12 Tiedon sytt ja tulostus
12.1 Sytt ja tulostus . . . . . . . . . . . . . . . . . . . .
12.2 Yksinkertaiset syttja tulostuslauseet . . . . .
12.3 Listan ohjaama muotoilu . . . . . . . . . . . . . . .
12.4 Sytt- ja tulostuslauseet . . . . . . . . . . . . . . .
12.5 Muotoilukoodit . . . . . . . . . . . . . . . . . . . . .
12.6 Muotoilukoodien yhdistminen ja tulostuslistat .
12.7 Tietueen osan tulostaminen tai lukeminen . . . .
12.8 Tiedostojen ksittely . . . . . . . . . . . . . . . . .
12.9 Luku merkkijonoista ja kirjoitus merkkijonoihin
12.10 NAMELIST-rakenne . . . . . . . . . . . . . . . . . . .
12.11 Virhetilanteiden ksittely . . . . . . . . . . . . . . .
12.12 Yhteenveto . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
192
192
193
194
196
197
202
204
204
209
210
210
211
13 Standardiproseduurit
13.1 Standardiproseduurien perusksitteit
13.2 Standardiproseduurien kuvauksia . . .
13.3 Esimerkki: kellonaika ja pivmr . .
13.4 Esimerkki: satunnaisluvut ja kellonaika
13.5 Esimerkki: bittienksittelyoperaatiot . .
13.6 Esimerkki: data pakkaaminen . . . . . .
13.7 Standardifunktioiden erityisnimet . . .
13.8 Listietoja . . . . . . . . . . . . . . . . . .
13.9 Yhteenveto . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
215
215
216
218
219
226
227
229
230
231
14 Esimerkkiohjelmia
14.1 Nelilaskin . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.2 Datan lajittelu . . . . . . . . . . . . . . . . . . . . . . . . . .
14.3 Sokkelon tekeminen . . . . . . . . . . . . . . . . . . . . . .
14.4 Yksiulotteinen soluautomaatti . . . . . . . . . . . . . . .
14.5 Life-soluautomaatti . . . . . . . . . . . . . . . . . . . . . .
14.6 Binripuu . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.7 Sukupuu . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.8 Optimointitehtvien ratkaiseminen: evoluutiostrategiat
14.9 Lineaaristen yhtlryhmien ratkaisu . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
234
234
237
243
247
253
256
261
263
269
15 Siirtyminen Fortran 95 -kieleen

15.1 Miten Fortran 95:een kannattaa siirty . . . . . . . . . .
15.2 Fortran 95:n uudet piirteet . . . . . . . . . . . . . . . . . .
15.3 FORTRAN 77:n huonoja puolia . . . . . . . . . . . . . . .
15.4 FORTRAN 77 -koodien muuntaminen uuteen muotoon
15.5 Ohjausrakenteiden kytt . . . . . . . . . . . . . . . . . .
15.6 COMMON-alueiden korvaus moduuleilla . . . . . . . . .
15.7 Fortranin vanhentuvat piirteet . . . . . . . . . . . . . . .
15.8 Vltettvi Fortranin piirteit . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
275
275
276
276
279
281
283
284
287
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
16 Fortran 2003
291
16.1 Fortran 2003:n trkeimmt lisykset ja parannukset . . . . . 291
16.2 Fortran 2003 ja olio-ohjelmointi . . . . . . . . . . . . . . . . . 295
Sislt
16.3
16.4
11
Fortran 2003:n tuki olio-ohjelmoinnille . . . . . . . . . . . . . 296

Listietoa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
17 Rinnakkaislaskenta HPF:ll ja OpenMP:ll

17.1 Vlineit rinnakkaislaskentaan . . . . . . . . . . . . . . . . . .
17.2 HPF-ohjelmoinnin perusteet . . . . . . . . . . . . . . . . . . . .
17.3 OpenMP: rinnakkaislaskenta yhteisen muistin koneissa . . .
299
299
299
305
Liite
309
Ohjelmoinnin kultaiset snnt

A.1
Yleisohjeita . . . . . . . . . . .
A.2
Ohjausrakenteet . . . . . . . .
A.3
Mrittele . . . . . . . . . . . .
A.4
Strukturoi . . . . . . . . . . . .
A.5
Standardoi . . . . . . . . . . . .
A.6
Dokumentointi . . . . . . . . .
A.7
Luettavuus . . . . . . . . . . . .
A.8
Vianetsint ja koodin testaus
A.9
Ohjelmakoodin optimointi . .
A.10 Sytt ja tulostus . . . . . . . .
A.11 Yhteenveto . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
310
310
310
311
311
311
311
312
312
313
313
314
Fortran 95:n hyvt, pahat ja rumat piirteet

315
B.1
Hyvt piirteet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
B.2
Toisinaan hydylliset piirteet . . . . . . . . . . . . . . . . . . . 316
B.3
Mahdollisesti vaaralliset piirteet . . . . . . . . . . . . . . . . . 316
Yhteenveto Fortran 95 -kielen lauseista
317
ASCII-merkist
324
Sanasto
325
Kirjallisuutta
329
Hakemisto
331
12
Fortran 95/2003
Teoksen sislt ja
merkinnt
Kerromme tss luvussa oppikirjan tarkoituksesta ja annamme neuvoja lukijalle. Kappaleesta 1.2 lydt kirjassa kytetyt merkinttavat.
1.1
Oppikirjan sisllst
Tm oppikirja on tiivis johdatus ohjelmointiin Fortran-kielell. Teos on

tarkoitettu opiskelijoille sek yliopistojen ja yritysten tutkijoille. Kirjaa voi
kytt oppikirjana Fortran-kursseilla ja itseopiskeluun.
Luotamme esimerkin voimaan. Siksi asiat on pyritty havainnollistamaan esimerkeill. Kunkin luvun loppuun on sijoitettu muutamia tehtvi tai kysymyksi luvun aihepiirist. Teoksessa on tehtvi erityisesti tieteellisen ja
teknisen laskennan alalta.
Tm kirja on tarkoitettu luettavaksi lpi jrjestyksess alusta loppuun. Koska Fortran-kielen monet piirteet liittyvt useampaan kuin yhteen aihepiiriin,
kydn oppikirjan alussa nopeasti lpi kielen trkeimmt piirteet. Toisaalta kukin luku on suunniteltu yhteniseksi kokonaisuudeksi, joten teosta voi
kytt mys ksikirjan tapaan.
Korostamme ohjelmoinnin kytnnn seikkoja, kuten koodin luettavuutta,
selkeytt ja yllpidettvyytt. Pyrimme esittmn kokonaisia ohjelmaesimerkkej pienten ohjelmakoodin katkelmien sijaan. Tmn ansiosta voit
helposti kokeilla esimerkkien toimintaa kytnnss. Esimerkkiohjelmat on
tarkoitettu luettavaksi yhdess niihin liittyvn tekstin kanssa. Tst johtuen
esimerkeiss on vhemmn selittvi kommentteja kuin itsenisiss ohjelmakoodeissa tulisi olla.
Luvussa 15 kydn lpi Fortran-kielen vanhempia piirteit. Luvussa kerrotaan, miten nm usein virheit aiheuttavat kielen piirteet voi korvata uuden
Fortran-standardin paremmilla ominaisuuksilla.
1. Teoksen sislt ja merkinnt
13
1.2 Kytetyt merkinnt ja esimerkkiohjelma

Fortran-kielen omat tunnukset on tss teoksessa kirjoitettu isoilla kirjaimilla. Kyttjn mrittelemien muuttujien ym. symbolien nimet on kirjoitettu
pienill kirjaimilla. Suosittelemme tt kytnt muutoinkin sovellettavaksi, vaikka se ei ole osa Fortranin mritelm.
Seuraavassa on esimerkki Fortran-ohjelmakoodista:
PROGRAM testaus
IMPLICIT NONE
REAL :: x
INTRINSIC SIN
WRITE (*,*) Anna x:
READ (*,*) x
WRITE (*,*) x = , x, SIN(x) = , SIN(x)
END PROGRAM testaus
Tm ohjelma lukee luvun x arvon ja tulostaa sinifunktion arvon SIN(x).

Fortran-ohjelmien yksityiskohtiin palataan seuraavissa luvuissa.
Tss teoksessa kytetn kirjasintyyppi teletype, kun esitetn ohjelmakoodia tai tietokoneen tuottamaa tulostusta. Kuitenkin jos halutaan selvsti
erottaa, mik teksti on kehotetta, mik kyttjn sytett ja mik tietokoneen tulostusta, on kytetty seuraavanlaisia kirjasintyyppej:
% f90 testaus.f90
% ./a.out
Anna x:
5
x =
5.0000000 SIN(x) =
-0.9589243
Tss tietokoneen kehote (prompt, merkki % yll) ja tulostus on ladottu

teletype-kirjasintyypill, ja kyttjn antamat komennot ja sytteet on
lihavoitu. Tss esimerkiss knsimme ohjelmakoodin testaus.f90 komennolla f90 ja ajoimme syntyneen ajokelpoisen ohjelman a.out. Ohjelmalle annettiin sytteen luku 5.
Teoksessa kytetn knnskomentoa f90, joka useissa jrjestelmiss on
identtinen komennon f95 kanssa. Fortran-ohjelmien tiedostopte voi olla
esimerkiksi .f90, .f95, .f03 tai .f riippuen kntjst.
Sellaiset nimet, joiden paikalle tulee kirjoittaa esimerkiksi tiedoston nimi,
on ladottu vinokirjaimilla:
f90 tiedosto.f90
Jos jokin mrittelyn osa voidaan jtt pois, kytmme hakasulkumerkint ([]) seuraavaan tapaan:
funktio([argumentti][, argumentti]...)
Kolme pistett (...) tarkoittaa tss nolla, yksi tai useampi kertaa toistettavaa osaa. Seuraavat ovat esimerkkej edellisen merkinnn kuvaamista funktiokutsuista:
h()
14
Fortran 95/2003
h(a)
h(a,b)
h(a,b,c)
Tekstiss esiintyvt lyhenteet ja erisnimet on yleens kirjoitettu kuten Fortran. Uusien termien esittelyyn ja muutenkin tekstin korostamiseen on kytetty kursiivia.
Tmn oppikirjan Fortran 90 -kielisten esimerkkiohjelmien kntmiseen ja
testaamiseen on kytetty NAGWareTM f90 -kntj, joka on aito Fortran 90
-kntj eik sisll standardin ulkopuolisia laajennuksia. Ohjelmat on testattu mys Macintoshissa kytten Absoftin Fortran 90 -kntj. Fortran 95 -piirteit sisltvt ohjelmat on testattu Digital Fortran 95 -kntjll.
Oppaan neljnness painoksessa on kytetty kntjn Sun Studio 9 Fortran 95 -kntjn versiota 8.0, joka ei tue Fortran 2003:n uusia piirteit.
1.3
Listietoja
Tmn teoksen aihepiirist lydt listietoja World Wide Web -jrjestelmst

eli www:st osoitteesta
http://www.csc.fi/oppaat/f95/
Tarjolla on mm. oppikirjan esimerkkiohjelmien lhdekoodeja, harjoitustehtvien ratkaisuja, mahdollisten painovirheiden korjauksia sek tietoa CSC:n
tarjoamista palveluista. Annamme mys viitteit muihin Fortrania ja ohjelmointia ksitteleviin www-palveluihin.
CSC:n www-kotisivu on osoitteessa
http://www.csc.fi
Hydyllisi Fortran-kielen ksikirjoja ovat teokset Fortran 95/2003 Explained [MRC04], Fortran 95 Language Guide [Geh96] ja Fortran 95 Handbook
[ABM+ 97]. Johdatukseksi kieleen sek oppikirjaksi sopivat teokset Introduction to Programming with Fortran [CS06] ja Fortran 90 Programming [EPL94].
Teos Programmers Guide to Fortran 90 [BGA94] on hyvin laaja ja monipuolinen johdatus Fortran-ohjelmointiin. Teos Migrating to Fortran 90 [Ker93]
sopii ohjenuoraksi vanhojen Fortran-koodien muuntamiseen uuden standardin mukaisiksi. Fortran 90:een perustuvaa F-kielt ksitelln teoksessa The
F Programming Language [MR96]. Artikkelissa The New Features of Fortran
2003 [Rei] kuvataan tiiviiss muodossa Fortran 2003:n uudet piirteet.
Fortran-standardeihin liittyvi dokumentteja lydt www-osoitteesta
http://www.nag.co.uk/sc22wg5/
Tietokoneohjelmissa kytettyj algoritmeja on esitelty mm. teoksissa Introduction to Algorithms [CLR90] ja Algorithms [Sed84].
CSC on tmn Fortran 95/2003 -oppikirjan lisksi julkaissut mm. matemaattista mallintamista ja numeerisia menetelmi ksittelevi teoksia:
1. Teoksen sislt ja merkinnt
15
Alkurjhdyksest knnykkn: nkkulmia laskennalliseen tieteeseen

[Haa02]
Laskennallinen tuotekehitys: suunnittelun uusi ulottuvuus [HJKR02]
Sillanrakennuksesta lkeainesuunnitteluun: Matemaattinen mallintaminen suomalaisissa yliopistoissa [HJL00]
Numeeriset menetelmt kytnnss [HHL+ 02]
Optimointitehtvien ratkaiseminen [Haa04]
Datan ksittely [Kar01].
16
Fortran 95/2003
Ohjelmoinnin
perusksitteet
Kerromme tss luvussa tietokoneen toiminnasta ja ohjelmointikielten kytst tietokoneen ohjaamiseen.
2.1
Mihin tarvitaan ohjelmointia
Ohjelmointitaito on ers trkeimmist teknis-tieteellisill aloilla tarvittavista

osaamisen alueista. Ohjelmointi ei tietenkn ole pmr sinns, vaan
vline, jonka avulla voidaan ratkoa kytnnss esiin tulevia tehtvi.
Ohjelmistoja tarvitaan lentokoneiden ja autojen suunnitteluun, prosessien
ohjaamiseen, datan kermiseen instrumenteista ja ihmisen geeniperimn
selvittmiseen (katso CSC:n julkaisemia teoksia [Haa02, HJKR02, HJL00]).
Jopa matematiikan teoreemojen todistamisessa kytetn apuna tietokoneohjelmia. Autojen, kameroiden ja pyykinpesukoneiden ohjelmistot tekevt nist laitteista monipuolisempia ja lykkmpi vaikkakin parantamisen varaa viel on!
Kaikkea ei kuitenkaan ole valmiiksi ohjelmoitu. Varsinkin eturivin tutkimusja tuotekehitystehtviss tarvitaan ohjelmointia ja olemassaolevien koodien
muokkausta. Kaikkea ei tietenkn tarvitse keksi uudestaan, sill on hyv ohjelmointityyli kytt apuna valmiiksi testattuja ja luotettavia ohjelmistoja. Olemassaolevien ohjelmistojen muokkaaminen tehtvn ratkaisemiseksi onkin tyypillist ohjelmoijan tykentt.
Silloin tllin kuulee vitteen: Jos osaan oman sovellusalueeni tarpeeksi hyvin, ei minun tarvitse osata ohjelmoida. Kun tehdn jotain uutta ja ennen
ratkaisematonta, ohjelmointia tarvitaan kuitenkin monilla aloilla muodossa tai toisessa. Lisksi erillisen ohjelmoijan palkkaaminen sovellusalueen
osaajan lisksi on melko kallista.
2. Ohjelmoinnin perusksitteet
17
2.2 Tietokoneet ja ohjelmointi

Vaikka tietokoneiden perusrakenne ei ole muuttunut paljonkaan viimeisten
40 vuoden aikana, on tietokoneiden kyttalue laajentunut nopeasti. Tm
voidaan lukea sek koneiden halpenemisen ett ohjelmointikielten kehittymisen ansioksi, sill ohjelmointia tarvitaan tietokoneiden kaikkien toimintojen ohjaamiseen.
Tietokoneen ymmrtm kieli koostuu joukosta konekskyj, joita suorittamalla tietokone saadaan tekemn haluttuja asioita. Tietokoneet pystyvt
suorittamaan miljardeja konekskyj sekunnissa. Erityyppiset tietokoneet
ymmrtvt kukin omaa konekieltn, joten konekielisen ohjelman siirto
koneesta toiseen on hankalaa ellei perti mahdotonta. Lisksi ohjelmointi
konekskyjen avulla on aikaaviev ja virhealtista puuhaa.
Tietokoneen ohjaaminen hoidetaan konekielen sijaan yleens ohjelmointikielen avulla. Tm mahdollistaa konekielt paremman ohjelmistojen siirrettvyyden. Ohjelmointikielen kntj (compiler) hoitaa automaattisesti
konekskyjen tuottamisen ohjelmakoodista. Tten ohjelmointikielen kytt
helpottaa huomattavasti tehtvien ratkaisua tietokoneella. Tm ei tarkoita
tietenkn sit, etteik ohjelmoinnissa silti tarvittaisi suurta huolellisuutta
ja tarkkuutta: kntj osaa lukea vain tarkasti ohjelmointikielen sntj
noudattavaa koodia eik pysty arvaamaan ohjelmoijan alkuperist tarkoitusta, jos sit ei ole ilmaistu yksiksitteisesti.
Eri ohjelmointikielet on suunniteltu erilaisiin tehtviin. Ohjelmointikieli on
kehitetty tuhansia, mutta vain muutamat niist ovat laajassa kytss.
2.3 Mit tarkoitetaan tietokoneella

Kuvassa 2.1 on esitetty tietokoneen toiminta yksinkertaisena kaaviona.
keskusmuisti
nppimist
keskusyksikk
kuvaruutu
tiedostot
Kuva 2.1: Tietokoneen toiminnan periaate.
Tietokoneen keskusyksikk toimii ohjelmakoodin sisltmien kskyjen mukaisesti. Ohjelma lukee tavallisesti joukon sytttietoja, jotka vaihtelevat ohjelman ajokerrasta toiseen. Ohjelma lukee sytttiedot sisn esimerkiksi
18
Fortran 95/2003
tiedostoista tai kyttjn nppimistlt. Sytttietoja voisivat olla esimerkiksi shavaintopisteist kertyt mittausarvot kuten lmptila, ilmanpaine
ja kosteus. Sennusteen laskemiseen kehitetty ohjelma voisi niden sytttietojen perusteella laskea ja tulostaa ennusteen seuraavien 48 tunnin ajaksi.
Tietokoneen keskusyksikk ksittelee keskusmuistissa sijaitsevaa dataa. Esimerkiksi sennusteen laskennan eri vaiheissa tarvittava data voidaan pit
tietokoneen keskusmuistissa. Keskusyksikk voi mys kirjoittaa ja lukea
tiedostoja, jotka mahdollistavat tiedon silyttmisen ohjelman suorittamisen loppuessa: kun ohjelman suoritus pttyy, kytetn vapautunut keskusmuisti seuraavien ohjelmien ajamiseen. Tt ennen tulee laskentatulokset tallettaa tiedostoihin, sill pysyvien tiedostojen sislt silyy ohjelman
suorittamisen loputtuakin. Tiedostojen ksittely on yleens hitaampaa kuin
keskusmuistin kytt.
Keskusyksikk voi tiedostoihin tallettamisen lisksi tulostaa tietoa kyttjn laitteen (ptteen, mikron tai tyaseman) kuvaruudulle. Tekstimuotoisen
tulostuksen lisksi tietokoneeseen voi olla kytkettyn graasten kuvaajien
piirtmiseen kykenevi laitteita.
2.4
Ohjelmoinnin eri vaiheet
Kun kehitt ohjelmistoa annettuun tehtvn, pid mieless seuraavat ohjelmoinnin vaiheet:
1. tehtvn tavoitteen mrittely
2. tehtvn analyysi ja ohjelmakoodin suunnittelu
3. ohjelmakoodin kirjoittaminen
4. testaaminen ja virheiden korjaaminen
5. dokumentointi
6. ohjelmiston kytt ja yllpitminen.
Tehtvn mrittelyss selvitetn tarkkaan, mit ohjelman tulisi tehd.
Mrittely kannattaa tehd huolellisesti, jottei koodia kirjoitettaessa tai testattaessa tarvitsisi huomata, ettei ohjelmisto ratkaise annettua tehtv.
Ohjelmoinnin trkein vaihe on tehtvn analyysi ja ohjelmakoodin suunnittelu. Ennen ohjelmakoodin kirjoittamista tytyy selvitt mm. ohjelmassa kytetyt tietorakenteet ja algoritmit. Thn vaiheeseen kannattaa kytt
runsaasti aikaa pienesskin tehtvss. Suunnitteluun kytetty aika saadaan
yleens runsain mitoin takaisin ohjelmakoodin kirjoittamisessa ja testaamisessa. Tehokas ja luotettava ratkaisumenetelm mys vhent ohjelman
korjailemiseen tarvittavaa aikaa.
19
Kirjoita ohjelmakoodi pienin osasina, joista kukin tekee oman tehtvns

hyvin. Kyt Fortran 95:n kehittyneit piirteit ohjelmakoodin modulaarisuuden lismiseksi. Minimoi riippuvuudet ohjelmiston eri osasten vlill ja
dokumentoi koodisi huolellisesti.
Kun kukin ohjelman osa on saatu koodattua, testaa sit ensin erikseen. Kiinnit testaukseen huomiota jo varhaisessa vaiheessa. Kytetyt testiaineistot
ja testiohjelmistot on syyt silytt ohjelmiston myhemp testausta varten. Hyvst testiaineistosta on apua esimerkiksi siirrettess ohjelmisto
uudelle koneelle tai tehtess ohjelmistoon muutoksia myhemmin.
Aloita ohjelmakoodin dokumentointi jo tehtvn mrittelyvaiheessa. Pid
mys huolta ohjelmakoodin luettavuudesta. Kyt sisennyst ja tyhji rivej
apuna koodin selkeyttmisess. l kommentoi suoraan ohjelman lauseiden
toimintaa, vaan kerro, mit ohjelmiston eri osissa tapahtuu.
Muista ohjelmoinnin kaikissa vaiheissa, ett ohjelmiston yllpitoon voi kulua
vuosien aikana paljon enemmn aikaa kuin ohjelmiston kehittmiseen alunperin. Pienillkin ohjelmakoodin ptkill on taipumus osoittautua yllttvn
pitkikisiksi. Ehkp vuosien kuluttua tytoverisi tulee kysymn, mit kehittmsi ohjelmakoodi oikeastaan tekee. Siis: dokumentoi huolellisesti ja
kirjoita selke koodia. Vlt kikkailua!
2.5 Ohjelman kntminen ja linkitys

Tmn kohdan sislt on oppaan muita osia riippuvaisempi kytettviss
olevasta Fortran-kntjst ja koneen kyttjrjestelmst. Tss esitellyt
asiat ptevt kuitenkin useimmissa koneympristiss pienin muutoksin.
Kuvassa 2.2 on esitetty ajettavan ohjelman tekemiseen tarvittavat vaiheet.
Kytnnss Fortran-koodista saa ajokelpoisen ohjelman seuraavasti:
1. kirjoita suunnitelman mukainen ohjelmakoodi yhteen tai useampaan
tiedostoon
2. knn lhdekooditiedostot objektikooditiedostoiksi
3. linkit objektikooditiedostot ja mahdolliset aliohjelmakirjastot suorituskelpoiseksi ohjelmaksi
4. aja syntynyt ohjelma ja tarkista tulokset.
Yksinkertaisissa tapauksissa voi kntmisen ja linkittmisen (vaiheet 2 ja 3)
tehd samalla komennolla.
Selvit kyttmsi koneen kyttoppaasta tai ksikirjasta, miten kntminen, linkittminen ja ohjelman ajaminen kytnnss tapahtuu. Useimmissa Unix-ympristiss yhdess tiedostossa olevan Fortran-ohjelmakoodin
kntminen ja ajaminen onnistuu seuraavasti:
% f90 tiedosto.f90
% ./a.out
20
Fortran 95/2003
Tss knnskomento oli nimeltn f90. Jos kytettviss on Fortran 95

-kntj, on knnskomento luultavasti nimeltn f95. Lhdekooditiedoston nimi pttyi merkkeihin .f90, mik on tyypillinen kytnt Unixissa.
Syntynyt ajokelpoinen ohjelma a.out ajettiin komennolla ./a.out.
Ohjelman kntminen ja linkittminen ajokelpoiseksi ohjelmaksi voidaan
tehd mys useassa vaiheessa:
%
%
%
%
f90 -c ali.f90
f90 -c ohj.f90
f90 -o ohj ali.o ohj.o -lnag
./ohj
Tss knsimme (ilman linkityst) ohjelmakoodin tiedostoissa ali.f90 ja

ohj.f90. Syntyneet objektikooditiedostot ali.o ja ohj.o linkitettiin ajokelpoiseksi ohjelmaksi nimelt ohj. Otimme ohjelmaan lisksi linkitysvaiheessa mukaan ohjelman kyttmt NAG-aliohjelmakirjaston rutiinit [Haa98].
Kyt ohjelmakoodin kirjoittamiseen sellaista editoria, joka osaa automaattisesti sisent koodirivit ja mahdollisesti mys tunnistaa Fortran 95 -kielen
avainsanat. Emacs on esimerkki tllaisesta editorista.
Kukin ohjelmayksikk (pohjelma, ulkoinen proseduuri tai moduuli) kannattaa yleens kirjoittaa omaan tiedostoonsa. Tllin voit knt kunkin
ohjelmayksikn erikseen, ja tehdesssi muutoksia ei aina ole vlttmtnt
knt koko ohjelmistoa uudestaan. Riitt, ett knnt uudestaan muuttuneet ohjelmayksikt (ja niit kyttvt ohjelmayksikt), jonka jlkeen tarvitsee vain linkitt ohjelmisto ajokelpoiseksi.
Fortran-kntjt tuottavat yleens tarvittaessa knnslistauksen, josta voi
olla hyty jljitettess ohjelmakoodiin pujahtaneita virheit. Kyt kn-
lhdekoodi
INCLUDE-tiedostot
kntj
tarvittaessa
knnslistaus
moduulit
objektikoodi
aliohjelmakirjastot
linkittj
tarvittaessa
linkitystaulu
ajettava
ohjelma
Kuva 2.2: Ohjelman kntmisen ja linkittmisen vaiheet. Moduuleja esitelln
luvussa 9 ja INCLUDE-lausetta kappaleessa 4.5.
21
nksess lisksi tarkkaa Fortran 95:n mukaista syntaksitarkistusta, sill

kntjkohtaiset kielen laajennukset vhentvt koodin siirrettvyytt. Syntaksitarkistus kytketn plle kntjn valitsimilla.
Fortran-kntjt optimoivat ohjelmakoodia pyydettess. Tllin pyritn
nopeuttamaan koodin suoritusta. Koodin optimointi kannattaa ottaa kyttn varsinaisissa tuotantoajoissa. Varmista sit ennen, ettei optimointi
muuta ohjelman toimintaa ja tuota virheellisi tuloksia.
Knnsaikana voi valita, halutaanko ohjelmaan mukaan ajonaikaiset taulukkorajojen tarkistukset. Yleens nist on niin paljon hyty, ett ne on
syyt kytke plle ainakin ohjelman kehittelyn aikana.
Kun eri ohjelmayksikt on knnetty objektikooditiedostoiksi, tarvitaan viel linkitys, jotta koodia voidaan ajaa. Tss yhteydess ottaa linkittj ohjelmaan mukaan mys mahdollisesti kytettvt aliohjelmakirjastot. Esimerkiksi Fortranin standardifunktiot ja -aliohjelmat linkitetn tarpeen mukaan
ohjelmaan.
Fortran-kielisi ohjelmia voi olla mahdollista linkitt muilla ohjelmointikielill kirjoitettujen ohjelmien yhteyteen. Vastaavasti voi olla mahdollista kutsua Fortranista muilla ohjelmointikielill kirjoitettuja rutiineita. Kytnnn
yksityiskohdat vaihtelevat laitteistosta toiseen.
Koska ohjelmankehityksess harvoin saadaan suoraan kirjoitettua virheetnt koodia, joudutaan ohjelmaa korjailemaan ja tekemn knns uudestaan. Kytettess Fortran 95:n moduuleita ja tyypinmrittelyit monet
virheet lydetn onneksi jo knnsaikana.
Mys linkitysvaiheessa voi ilmet virheit esimerkiksi vrin kirjoitetun aliohjelman nimen vuoksi. Tarvittaessa voit pyyt linkittj tulostamaan linkitystaulun, josta nkyy ohjelmassa kytettyjen proseduurien nimet.
Vaikeimpia jljitettvi ovat vasta ohjelman ajon aikana ilmenevt virheet.
Ohjelma voi lisksi kyttyty vrin vain joissakin erikoistilanteissa. Tmn
vuoksi onkin syyt testata ohjelmakoodia huolellisesti ennen sen ottamista
tuotantokyttn. Jos ohjelma on iso ja monimutkainen, kannattaa sen eri
osia testata erikseen.
Kytettvisssi voi olla mys tutkinta- ja virheenjljitysohjelmia (debugger),
joiden avulla voi etsi ohjelmakoodiin pujahtaneita virheit.
2.6 Yhteenveto
Ohjelmointia tarvitaan tietokoneen kaikkien toimintojen ohjaamiseen.
Trkein ohjelmoinnin vaihe on tehtvn analyysi ja ohjelmakoodin suunnittelu.
Muista mys ohjelmakoodin testaaminen virheiden lytmiseksi.
22
Fortran 95/2003
Harjoitustehtvi
1. Mik on ohjelmointikielen kntjn tehtv?
2. Kokeile kappaleessa 1.2 (sivu 13) esitetyn ohjelmakoodin kntmist
ja ajamista kytettvisssi olevalla laitteistolla.
3. Muuta edellisen tehtvn ohjelmakoodia siten, ett se tulostaa luvun
x nelijuuren SQRT(x). Syt ohjelmalle negatiivinen luku. Mit tapahtuu?
3. Johdatus ohjelmointiin Fortran 95:ll
23
Johdatus ohjelmointiin
Fortran 95:ll
Esittelemme trkeimmt Fortran 95 -ohjelmointikielen piirteet yksinkertaisten esimerkkien avulla. Alussa kerromme lyhyesti Fortran-kielen merkityksest ja historiasta. Luku kannattaa silmill lpi, vaikka Fortran-kielen vanhemmat versiot olisivat tuttuja. Esiteltvt asiat kydn yksityiskohtaisemmin lpi myhemmiss luvuissa.
3.1 Fortran-kielen merkitys

Fortran on vanhin ja eniten kytetty tieteellisen ja teknisen laskennan ohjelmointikieli. Fortran-kielen kehitys lhti kyntiin IBM:ll vuonna 1954, jolloin
esiteltiin suunnitelma ohjelmointikielest nimelt FORmula TRANslator eli
FORTRAN.
Fortranin kytetyimpi versioita ovat olleet FORTRAN IV, FORTRAN 66 ja
FORTRAN 77. Fortran oli mys ensimminen ohjelmointikieli, josta luotiin standardi (FORTRAN 66 vuonna 1966). Vuonna 1978 valmistui viel
nykynkin kytetty vaikkakin jo vanhahtava FORTRAN 77 -standardi.
Fortran 90 -kielen ISO- ja ANSI-standardi hyvksyttiin vuosina 1991 ja 1992
(standardit ISO/IEC1539:1991 ja ANSI X3.198-1992). Tss kirjassa posin
ksiteltv Fortran-kielen versio, Fortran 95, hyvksyttiin vuonna 1997 kansainvliseksi standardiksi (ISO/IEC1539:1997). Kansainvlinen (ISO) ja amerikkalainen (ANSI) standardi ovat sisllltn samat. Teoksessa kytetn
Fortran-nimest kirjoitusasua FORTRAN, jos viitataan aiempiin Fortrankielen versioihin. Kirjoitustapa Fortran tarkoittaa yleens Fortran-kielt ja
erityisesti Fortran 95 -standardin sislt. Uusin standardi, Fortran 2003,
julkaistiin vuonna 2004 (ISO/IEC 1539-1:2004(E)).
Fortran 90 oli merkittv edistysaskel Fortran-kielen kehityksess. Standardi toi Fortranin muiden ohjelmointikielten tasolle. Osaa Fortran 90 -kielen
uusista ominaisuuksista ei edes lydy muista ohjelmointikielist. Fortran 95
oli sen sijaan pienehk pivitys standardiin; suurimmat lisykset liittyvt
rinnakkaislaskentaan.
Uusin standardi eli Fortran 2003 on suuri muutos kieleen sislten mm.
24
Fortran 95/2003
olio-ohjelmointiin liittyvi ominaisuuksia. Seuraava pivitys standardiin on

tynimeltn Fortran 2008, ja tuo tarjolle entisestn uusia piirteit. Tss
oppaassa keskitytn Fortran 95:n sisltn.
Fortran-ohjelmointikieli on kehitetty tehokkaaseen numeeriseen laskentaan.
Koska Fortran 95 sislt osajoukkonaan FORTRAN 77:n, voit kytt vanhoja koodeja osana uutta ohjelmistoa. Lisksi Fortran-kieli soveltuu entistkin
paremmin suuriin ohjelmistoprojekteihin.
Koska Fortran-kieli on standardoitu, on ohjelmakoodi helppo siirt uuteen
tietokoneeseen, jos kyseisell koneella on kytettviss Fortran-kielen kntj. Koodien siirrettvyytt voikin pit yhten ohjelmointikielen trkeimmist ominaisuuksista. Tm korostuu entisestn uusien tietokonesukupolvien seuratessa toisiaan kiihtyvll vauhdilla: vaikka laitteisto vaihtuu,
useimmiten uudessa koneessa halutaan ajaa samoja ohjelmistoja kuin aikaisemminkin.
Fortran-kieli on koodien siirrettvyyden kannalta parhaimpia ohjelmointikieli. Standardia noudattavan ohjelmakoodin siirtminen halutulle koneelle onnistuu usein ilman koodin muuttamista. Koneriippuvia ohjelman osia
ovat lhinn syttja tulostuslauseet sek tiedostojen ksittely.
3.2
Fortran 95:n trkeimmt uudet piirteet
Vanhaan Fortran-kieleen tottuneille nkyvin Fortran 95:n muutos on uuden

lhdekoodimuodon kyttnotto. Tm vapaa lhdekoodin muoto ei en
ole sarakesidonnainen, vaan kielen lauseet voi sijoittaa vapaasti maksimissaan 132 merkin pituisille riveille. Tunnuksien nimiss saa olla 31 merkki
(entisen kuuden sijasta!), ja alaviiva _ on luvallinen symboli tunnuksissa
kirjainten (A . . . Z) ja numeroiden (0 . . . 9) lisksi.
Ohjelmointia tehostavat monipuolistuneet muuttujien mrittelyt. Nyt voi
luoda omia rakenteisia muuttujatyyppej, joiden avulla monet aiemmin hankalasti ratkaistut ohjelmointitehtvt onnistuvat suoraviivaisesti ja helposti.
Lisksi taulukkomuuttujien tilan voi varata ohjelman ajon aikana dynaamisesti, joten aikaisempien Fortran-versioiden vaatimista hankalista tytilavektoreista pstn vihdoin eroon.
Uudet ohjausrakenteet sek esimerkiksi taulukkosyntaksi mahdollistavat
luettavamman ja selkemmn koodin kirjoittamisen. Voit mys kytt taulukkosyntaksia rinnakkaisuuden esittmiseen ohjelmakoodin tasolla.
Moduulirakenteet ja sisiset aliohjelmat mahdollistavat ohjelmakoodin pilkkomisen erillisiin, riippumattomiin osiin (modulaarisuus). Nm ominaisuuksien avulla tehdn mys proseduurien argumenttilistojen knnsaikaisia tarkistuksia. Nm piirteet hydyttvt sek aloittelevaa ohjelmoijaa
ett suurten ohjelmistoprojektien parissa tyskentelevi ammattilaisia.
Fortran-kieli silytt uusien piirteiden lisksi mys perinteiset vahvuuteensa: esimerkkein tehokkuus numeerisessa laskennassa sek monipuoliset ja
tehokkaat syttja tulostustoiminnot.
25
3.3 Miksi Fortran-kielt kannattaa kytt

Fortran-ohjelmointikielen trkein etu on kielen yleisesti hyvksytty standardi. Koska lhestulkoon kaikille tietokoneille on saatavissa standardin mukainen Fortran-kntj, on koodien siirtminen mahdollista melkein mihin
tahansa koneympristn.
Fortran-kielen vahvuuksia on soveltuvuus numeeriseen laskentaan. Kieless
on paljon sellaisia piirteit, jotka ovat muissa kieliss ylimrisi laajennuksia tai hankalasti listtvi piirteit (esimerkkein kompleksilukujen
aritmetiikka ja taulukkosyntaksi).
Fortran-kielt kehitetn aktiivisesti edelleen. Esimerkiksi rinnakkaislaskentaa varten on kehitetty Fortran 95 -kielen laajennus High Performance Fortran (HPF). Rinnakkaisohjelmointi onnistuu mys OpenMP:n avulla. Rinnakkaislaskentaa ksitelln luvussa 17 (sivu 299).
Fortran 95 -standardi on posin yhteensopiva aiempiin Fortran-kielen standardeihin nhden. Tten aiemmin kehitetyt Fortran-koodit toimivat mys
jatkossa. Pieni osa FORTRAN 77 -kielen piirteist mriteltiin vanhentuneiksi, mutta useimmat Fortran 95 -kntjt sallivat silti niden piirteiden kytn.
Saatavilla on paljon valmiita Fortran-kielisi ohjelmistoja, joita voi kytt
hyvksi omassa ohjelmointityss. Usein ohjelmointi onkin olemassaolevan
koodin muokkaamista uusia tarpeita vastaavaksi.
3.4 Fortran-ohjelman perusrakenne

Ohjelmoimaan oppii vain ohjelmoimalla. Tss teoksessa esitettyj esimerkkej kannattaa kokeilla itse. Pienten muutosten tekeminen esimerkkiohjelmiin on hyv tapa oppia ymmrtmn Fortranin mahdollisuuksia.
Fortran-kielt voi kytt taskulaskimen tapaan tekemn yksinkertaisia
laskutoimituksia. Seuraavassa on alkeellinen esimerkkiohjelma:
PROGRAM laskuesimerkki
WRITE (*,*) 7*52 + 1
END PROGRAM laskuesimerkki
Tm ohjelmakoodi koostuu kolmesta rivist, joista kullakin on yksi Fortranin lause. Lauseessa esiintyvt tunnukset erotetaan toisistaan vlilynneill.
WRITE-lauseen sisentmiseen on kytetty vlilyntej, jolloin koodi on selkempi lukea.
PROGRAM-lause antaa ohjelmalle nimen, ja END PROGRAM -lause lopettaa ohjelmayksikn suorituksen. WRITE-lausetta kytetn tulostukseen. Merkint
7*52 tarkoittaa kertolaskua ja merkki + yhteenlaskua. Lause WRITE (*,*)
7*52 + 1 tulostaa laskutoimituksen 7 52 + 1 tuloksen kuvaruudulle.
Kun olemme kirjoittaneet tmn ohjelmakoodin tiedostoon laskut.f90,
26
Fortran 95/2003
saamme ohjelman knnetty ajokelpoiseksi ohjelmaksi Unix-koneissa tyypillisesti komennolla

% f90 -o laskut laskut.f90
Tiedoston nimi pttyy merkkeihin .f90, mist kntj tunnistaa tiedoston

Fortran-lhdekooditiedostoksi. Jos knnksess ei ollut ongelmia, voimme
ajaa syntyneen ohjelman laskut esimerkiksi seuraavasti:
% ./laskut
365
Ohjelma siis tulosti laskutoimituksen 7 52 + 1 tuloksen.

Fortran-ohjelma voi tulostaa mys merkkijonoja:
PROGRAM laskuesimerkki_2
WRITE (*,*) 7*52 + 1 =, 7*52 + 1
END PROGRAM laskuesimerkki_2
Tmn ohjelman tulostus nytt tlt:

7*52 + 1 = 365
Siis lainausmerkeiss ( . . . ) ollut merkkijono tulostettiin sellaisenaan.
3.5
Tunnusten nimeminen
Edellisess esimerkiss aloitettiin pohjelma PROGRAM-lauseella. Ohjelmakoodi lopetettiin lauseella END PROGRAM. Jokaisessa ajokelpoisessa ohjelmassa on vain yksi pohjelma.
Ohjelman tunnus oli ensimmisess esimerkiss laskuesimerkki. Tunnuksen pituus saa olla korkeintaan 31 merkki, ja tunnukseen kelpaavat kirjaimet A . . . Z, alaviiva _ sek numerot. Nm snnt koskevat kyttjn
mrittelemien tunnusten lisksi mys Fortranin omia tunnuksia.
Tss oppaassa kytetn itse mritellyiss tunnuksissa pieni kirjaimia.
Fortran-kielen kannalta nimet lasku, Lasku ja LASKU ovat identtisi, mutta
pienet kirjaimet parantavat koodin luettavuutta. Fortran 95 -standardi ei
ehdottomasti vaadi, ett kntj hyvksyisi pienet kirjaimet, mutta kaikki
kntjt nyttvt sen tekevn.
Tunnusten nimien on syyt olla jrkevi ja helposti ymmrrettvi. Tunnusten nimeminen on osa ohjelman dokumentointia! Esimerkiksi jos tunnuksen nimi viittaa eri asiaan kuin mihin tunnusta kytetn, aiheuttaa tm
sekaannuksen vaaran.
27
3.6 Vakiot ja peruslaskutoimitukset

Edellisess esimerkiss laskimme lausekkeen 7*52 + 1 arvon. Lausekkeessa esiintyy kolme kokonaislukuvakiota. Mys lausekkeen tulos 365 on kokonaisluku. Kokonaislukuvakiolla voi mys olla etumerkki (+ tai -), esimerkkin tst on vakio -5.
Kokonaislukujen lisksi Fortran osaa laskea mys reaaliluvuilla. Seuraavassa
tulostetaan reaalilukuvakioita sisltvn laskutoimituksen tulos:
WRITE (*,*) 52.0/7.0
Operaatio / tekee jakolaskun. Tmn lauseen tulostus voisi olla

7.4285712
Tietokone laskee rellisell tarkkuudella. Tss tapauksessa tuloksen tarkkuus on noin kuusi desimaalia, vaikka ohjelma tulostaa kahdeksan numeroa.
Reaalikuluvakiot erotetaan kokonaisluvuista desimaalipisteen avulla. Reaaliluvut voi esitt mys eksponenttiesityksen avulla:
WRITE (*,*) 0.52E2/0.7E1
Tm lauseke tulostaa saman kuin edell. Merkint 0.52E2 tarkoittaa arvoa

0.52 102 = 52.0. Merkint 520E-1 tarkoittaisi mys samaa arvoa: 520
101 = 52.0.
Fortranin ymmrtmt peruslaskutoimitukset ovat +, -, *, / ja **. Nm
operaatiot vastaavat yhteen-, vhennys-, kerto- ja jakolaskua sek potenssiin
korottamista. Esimerkiksi lausekkeen 2**3 arvo on 23 = 8.
Laskutoimitusten tulos riippuu argumenttien tyypist. Lause
WRITE (*,*) 52.0/7.0 =, 52.0/7.0, , 52/7 =, 52/7
tulostaa seuraavaa:
52.0/7.0 =
7.4285712 , 52/7 = 7
Siis kokonaislukujen jakolaskun 52/7 tulos on mys kokonaisluku, ja murtoosa jtettiin huomiotta. Tarkista siis aina jakolaskun argumenttien tyypit!
Jos jakolaskun argumenteista toinen on reaalilukutyyppi, on tuloskin reaaliluku. Siten lausekkeen 52.0/7 arvoksi saadaan 7.4285712.
Sulkumerkkej ( ja ) voi kytt laskutoimitusten ryhmittelyyn:
WRITE (*,*) 52.0/7.0 + 1.0, (52.0/7.0)+1.0, 52.0/(7.0 + 1.0)
Tm lause tulostaa seuraavaa:

8.4285717
8.4285717
6.5000000
Koska jakolasku suoritetaan ennen yhteenlaskua, ovat edell kaksi ensimmist lauseketta identtiset, joten sulkujen kytt ei siis ole vlttmtnt.
Kolmannessa lausekkeessa ovat sulut vlttmttmt, muuten lausekkeen
tarkoitus muuttuu.
Merkkijonovakiot voi esitt joko yksinkertaisilla lainausmerkeill (tyyliin
28
Fortran 95/2003
merkkijono) tai kaksinkertaisilla lainausmerkeill ("merkkijono"). Jos

merkkijono sislt lainausmerkin, tytyy se kahdentaa tai laittaa toisentyyppisten lainausmerkkien sisn:
WRITE (*,*) yhtkki oli kes
WRITE (*,*) "yhtkki oli kes"
3.7
Muuttujat
Edellisiss esimerkeiss kytettiin pelkstn ohjelmakoodiin sijoitettuja

vakioita. Jos ohjelman halutaan laskevan jotain muuta, joudutaan tllin
muuttamaan ohjelmakoodia ja kntmn ohjelma uudestaan. Muun muassa tmn takia ohjelmoinnissa kytetn muuttujia, jotka voivat saada eri
arvoja ohjelman ajokerrasta toiseen.
Olkoon tehtvn kirjoittaa seuraavasti toimiva ohjelma:
1. pyydetn syttmn kaksi lukua
2. luetaan lukuarvot nppimistlt
3. tulostetaan sytetyt luvut ja niiden tulo.
Tm voidaan tehd seuraavalla ohjelmalla:
PROGRAM kertolasku
! Ohjelma lukee kaksi kokonaislukua sek
! laskee ja tulostaa niiden tulon.
IMPLICIT NONE
INTEGER :: i, j
WRITE (*,*) Syt luku i:
READ (*,*) i
WRITE (*,*) Syt luku j:
READ (*,*) j
WRITE (*,*) Luku i:, i
WRITE (*,*) Luku j:, j
WRITE (*,*) Tulo i*j:, i*j
END PROGRAM kertolasku
Huutomerkill (!) alkavat rivit ovat kommentteja ja ne on tarkoitettu ohjeeksi ohjelman lukijalle ja kyttjlle. Mrittely IMPLICIT NONE parantaa
kntjn tekemi virheentarkistuksia. Se on syyt laittaa jokaiseen ohjelmayksikkn otsikkolauseen (PROGRAM tms.) jlkeen. Tm lause poistaa
kytst tunnuksen ensimmiseen kirjaimeen perustuvan tyyppimrittelyn, josta kerrotaan tarkemmin kappaleessa 5.4 (sivu 55).
Ohjelmassa mritelln kokonaislukumuuttujat i ja j rivill
INTEGER :: i, j
Ensimminen WRITE-lause tulostaa kehotteen sytt muuttujalle i arvo.

Nppimistlt lukemiseen kytetn lausetta
29
READ (*,*) i
Tllin muuttuja i saa arvokseen kyttjn antaman luvun. Sama tehdn

muuttujalle j. Lopuksi ohjelma tulostaa muuttujien i ja j arvot ja kertolaskun i*j tuloksen. Muuttujia voi siis kytt vakioiden tavoin aritmeettisissa
lausekkeissa.
Ohjelman toiminta voisi olla seuraavaa:
Syt luku i:
11
Syt luku j:
13
Luku i: 11
Luku j: 13
Tulo i*j: 143
Kyttj siis sytti ohjelmalle luvut 11 ja 13, ja ohjelma tulosti arvon 11

13 = 143.
3.8 Muuttujien tyypit

Edell mrittelimme kokonaislukutyyppisi (INTEGER) muuttujia. Kokonaislukujen lisksi voimme mritell reaalilukutyypin (REAL) muuttujia:
PROGRAM potenssi
! Ohjelma laskee ja tulostaa numeerisen lauseekkeen arvon.
IMPLICIT NONE
REAL :: k, x
INTEGER :: n
WRITE (*,*) Syt lausekkeen k*x**n luvut k, x ja n:
READ (*,*) k, x, n
WRITE (*,*) Luku k:, k, Luku x:, x, Luku n:, n
WRITE (*,*) Arvo k*x**n:, k*x**n
END PROGRAM potenssi
Muuttujat k ja x ovat reaalilukuja ja muuttuja n on kokonaisluku. Ohjelma

lukee muuttujien arvot, tulostaa ne sek laskee lausekkeen kx n arvon.
Voimme kytt ohjelmaa seuraavasti:
Syt lausekkeen k*x**n luvut k, x ja n:
5.0 1.23 3
Luku k:
5.0000000 Luku x:
1.2300000
Arvo k*x**n:
9.3043346
Luku n: 3
3.9 Sijoituslauseet
Edellisess ohjelmassa luimme tietoa muuttujiin k, x ja n sek tulostimme lausekkeen k*x**n arvon. Yleens tarvitsemme tt monipuolisempia
lausekkeita.
30
Fortran 95/2003
Sijoituslauseella voimme antaa muuttujalle arvon. Seuraavassa on pieni esimerkkiohjelma:

PROGRAM neliojuuri
! Ohjelma laskee nelijuurilausekkeen arvon.
IMPLICIT NONE
REAL :: x, y
INTRINSIC SQRT
WRITE (*,*) Syt luku x:
READ (*,*) x
y = x**2 + 1
WRITE (*,*) Luku x:, x
WRITE (*,*) Arvo x**2 + 1:, y
WRITE (*,*) Arvo SQRT(x**2 + 1):, SQRT(y)
END PROGRAM neliojuuri
Tss ohjelmassa mrittelimme kaksi reaalilukumuuttujaa rivill

REAL :: x, y
Lauseella INTRINSIC SQRT kerrotaan, ett ohjelmassa kytetn Fortranin

standardifunktiota SQRT, joka laskee luvun nelijuuren arvon.
Muuttujaan x luetaan arvo nppimistlt, ja tmn jlkeen sijoitetaan lausekkeen x**2 + 1 arvo muuttujaan y rivill
y = x**2 + 1
Lopuksi ohjelma tulostaa muuttujan y arvon sek lausekkeen SQRT(y) arvon. Seuraavassa on esimerkki ohjelman kytst:
Syt luku x:
2.345
Luku x:
2.3450000
Arvo x**2 + 1:
6.4990253
Arvo SQRT(x**2 + 1):
2.5493186
Ohjelma tulostaa reaaliluvut kahdeksan numeron pituisina. Tulostetuissa

arvoissa on noin kuusi merkitsev desimaalinumeroa, koska reaaliluvuilla
lasketaan rellisell tarkkuudella.
3.10
Omien funktioiden mrittely ja kytt
Edell kytimme Fortranin standardifunktiota SQRT nelijuuren laskemiseksi. Mys omien funktioiden mritteleminen on mahdollista. Seuraavassa ohjelmakoodissa mrittelemme funktion f, joka vastaa matemaattista mritelm f (a) = a2 + 1:
PROGRAM funktio_esimerkki
! Ohjelma lukee reaaliluvun x ja tulostaa
! funktion f arvon tss pisteess.
31
IMPLICIT NONE
REAL :: x
WRITE (*,*) Syt luku x:
READ (*,*) x
WRITE (*,*) Luku x:, x
WRITE (*,*) Arvo f(x):, f(x)
CONTAINS
FUNCTION f(a) RESULT(f_arvo)
IMPLICIT NONE
REAL :: a, f_arvo
f_arvo = a**2 + 1
END FUNCTION f
END PROGRAM funktio_esimerkki
Tm esimerkkiohjelma toimii seuraavasti:

Syt luku x:
2.345
Luku x:
2.345000
Arvo f(x):
6.499025
Funktion f arvo lasketaan funktiokutsulla f(x). Funktio f on mritelty pohjelman sisisen funktiona CONTAINS-lauseen jlkeen.
Funktioista kerromme lis luvussa 8 sivulta 99 alkaen.
Seuraavassa on ote funktion f mrittelyst:
FUNCTION f(a) RESULT(f_arvo)
REAL :: a, f_arvo
Funktion f muodollinen argumentti a on mritelty funktion otsikkorivill. Muodollinen argumentti saa arvokseen funktiokutsussa f(x) esiintyvn
todellisen argumentin x arvon.
Funktion f arvo lasketaan muuttujaan f_arvo seuraavasti:
f_arvo = a**2 + 1
Sek muodollinen argumentti a ett funktion palauttama arvo f_arvo ovat

tss tapauksessa tyyppi REAL.
Voimme kytt funktiota f esimerkiksi seuraavasti:
y = f(x)
y = f(1.0)
y = f(1.23E2)
Toisaalta funktiokutsut
y = f(1)
y = f(1,0)
johtavat knnsaikaiseen virheeseen: ensimmisess kutsussa argumentti

on vr tyyppi (kokonaisluku) ja toisessa kutsussa on lisksi vr mr
argumentteja.
Knnsaikaiset argumenttilistojen tarkistukset ovat hydyllisi ohjelmankehityksen kaikissa vaiheissa. Jos edellisess esimerkkikoodissa desimaali-
32
Fortran 95/2003
piste olisi muuttunut vahingossa pilkuksi, huomataan virheellinen funktiokutsu f(1,0) jo knnsaikana. Tt ominaisuutta ei ollut FORTRAN 77:ss.
3.11
Toistorakenteet
Fortranissa hoidetaan lauseiden toistaminen DO-silmukkojen avulla. Laskemme esimerkkin lausekkeen

1 x
1+
x
arvot, kun x on 21 , 22 , . . . , 210 eli 2, 4, . . . , 1024. Seuraava ohjelmakoodi tulostaa halutut arvot:
PROGRAM silmukka
IMPLICIT NONE
REAL :: x
INTEGER :: i
DO i = 1, 10
x = REAL(2**i)
WRITE (*,*) arvot:, x, (1 + 1/x)**x
END DO
END PROGRAM silmukka
Muuttuja x on mritelty REAL-tyyppiseksi, jolloin lausekkeessa 1/x vltetn kokonaislukujen jakolasku. Funktiokutsu REAL(2**i) muuttaa puolestaan kokonaislukulausekkeen 2**i reaalilukutyyppiseksi.
DO-silmukka mritelln seuraavasti:
DO silmukkamuuttuja = alaraja, ylraja
lauseet
END DO
Silmukkamuuttuja ky jrjestyksess lpi arvot

alaraja, alaraja + 1, alaraja + 2, . . . , ylraja.
Tss tytyy silmukkamuuttujan sek ala- ja ylrajojen olla kokonaislukutyyppi.
Edellisess esimerkiss silmukkamuuttuja i ky lpi arvot 1, 2, 3, . . . , 10. Ohjelma tulostaa esimerkiksi seuraavaa (tulostusta muotoillaan paremman nkiseksi jatkossa):
arvot:
arvot:
arvot:
arvot:
arvot:
arvot:
arvot:
arvot:
2.0000000
2.2500000
4.0000000
2.4414062
8.0000000
2.5657845
16.0000000
2.6379285
32.0000000
2.6769900
64.0000000
2.6973450
1.2800000E+02
2.7077391
2.5600000E+02
2.7129917
arvot:
arvot:
5.1200000E+02
1.0240000E+03
33
2.7156320
2.7169557
Kun muuttujan x arvo kasvaa, lhestyy lausekkeen (1 + 1/x)**x arvo matemaattista vakiota e 2.71828.
3.12
Taulukot ja rakenteiset tyypit
Ksittelemme seuraavassa esimerkiss kurssille osallistujien nimi- ja arvosanatietoja. Sijoitamme merkkijonomuuttujiin nimi_1 . . . nimi_4 osallistujien nimet. Nimess saa olla korkeintaan 30 merkki. Arvosanat sijoitamme
muuttujiin arvosana_1 . . . arvosana_4.
CHARACTER (LEN=30) :: nimi_1, nimi_2, nimi_3, nimi_4
REAL :: arvosana_1, arvosana_2, arvosana_3, arvosana_4
REAL :: keskiarvo
nimi_1 = Iiro V.
arvosana_1 = 7.25
nimi_2 = Sauli N.
arvosana_2 = 7.0
jne.
Voimme laskea arvosanojen keskiarvon seuraavasti:

keskiarvo = (arvosana_1 + arvosana_2 + arvosana_3 + &
arvosana_4)/4
Yll merkki & kertoo, ett sijoituslause jatkuu seuraavalle riville.

Jos osallistujia olisi esimerkiksi 120, tytyisi mritell 120 muuttujaa sek nimi ett arvosanoja varten. Yksittisten muuttujien sijaan kannattaakin kytt taulukkoja, joiden alkioiden lukumr ilmoitetaan mreell
DIMENSION:
INTEGER, PARAMETER :: lkm = 120
CHARACTER(LEN=30), DIMENSION(lkm) :: nimet
REAL, DIMENSION(lkm) :: arvosanat
Mrittelimme tunnuksen lkm kokonaislukutyyppisen nimetyn vakion tunnukseksi kyttmll mrett PARAMETER. Vakion lkm arvo on 120. Tmn jlkeen mrittelimme taulukot nimet ja arvosanat, joissa kummassakin on lkm alkiota. Taulukko nimet on merkkijonotyyppi, ja taulukko
arvosanat on reaalilukutyyppi.
Taulukkojen alkioille voimme antaa arvot seuraavasti:
nimet(1) = Iiro V.
arvosanat(1) = 7.25
nimet(2) = Sauli N.
arvosanat(2) = 7.0
jne.
34
Fortran 95/2003
Merkint tunnus(n) viittaa taulukon n:nteen alkioon. Tss esimerkiss taulukkojen indeksi n voi olla vlill 1, 2, . . . , 120.
Fortranin standardifunktio SUM laskee taulukon alkioiden summan. Taulukkoon arvosanat sijoitettujen arvosanojen keskiarvo voidaan siis laskea seuraavasti:
REAL :: keskiarvo
keskiarvo = SUM(arvosanat)/lkm
Edell kytimme erillisi taulukkoja nimille ja arvosanoille. Seuraavassa mrittelemme rakenteisen tyypin, joka sislt erilliset kentt oppilaan nimelle
ja arvosanalle:
TYPE kurssilainen
CHARACTER(LEN=30) :: nimi
REAL :: arvosana
END TYPE kurssilainen
FORTRAN 77 ei sisltnyt mahdollisuutta kytt rakenteisia tyyppej.

Nyt voimme mritell 120 alkiosta koostuvan taulukon, jonka alkiot ovat
tt tyyppi:
TYPE(kurssilainen), DIMENSION(lkm) :: oppilaat
Voimme kytt taulukkoa oppilaat seuraavasti:

oppilaat(1)%nimi = Iiro V.
oppilaat(1)%arvosana = 7.25
oppilaat(2)%nimi = Sauli N.
oppilaat(2)%arvosana = 7.0
jne.
Viittasimme taulukon alkioihin edell, mutta nyt kukin alkio on rakenteista

tyyppi. Tyypin kurssilainen kenttiin viitataan merkinnll alkio % kentt.
Siten lauseke oppilaat(i)%arvosana viittaa i:nnen oppilaan arvosanaan.
Arvosanojen keskiarvo voitaisiin laskea seuraavasti:
keskiarvo = SUM(oppilaat%arvosana)/lkm
Tss merkint oppilaat%arvosana viittaa kaikkien 120 oppilaan arvosanoihin. Merkin % ymprill saa kytt vlilyntej:
keskiarvo = SUM(oppilaat % arvosana)/lkm
Edell esitetty monipuolisempi esimerkki rakenteisten tyyppien kytst

lytyy kappaleesta 14.7 sivulta 261. Tss esimerkiss sytetn tietokoneeseen perheen sukupuu, josta voi tehd hakuja vaikkapa etunimen perusteella.
3.13
35
Tulostuksen muotoilu
Kappaleen 3.11 esimerkiss tulostettiin merkkijono, reaaliluku ja kokonaisluku kytten lausetta

WRITE (*,*) arvot:, x, (1 + 1/x)**x
Tmn lauseen pitempi muoto on

WRITE (UNIT=*,FMT=*) arvot:, x, (1 + 1/x)**x
Ensimminen thti vastaa oletusarvoista tulostuskanavaa (unit), joka on

yleens kyttjn laitteen nytt. Toinen thti tarkoittaa, ett kntj valitsee tulostettavalle datalle sopivan oletusarvoisen tulostusasun (format).
Oletusmuotoilun * sijaan voidaan tulostusta ohjata mys erityisell muotoilukoodilla. Tulostuslause voi olla seuraava:
WRITE (*,(A6,F7.1,F7.4)) arvot:, x, (1 + 1/x)**x
Ohjelma tulostaa tllin seuraavan:

arvot:
2.0
arvot:
4.0
arvot:
8.0
arvot:
16.0
arvot:
32.0
arvot:
64.0
arvot: 128.0
arvot: 256.0
arvot: 512.0
arvot: 1024.0
2.2500
2.4414
2.5658
2.6379
2.6770
2.6973
2.7077
2.7130
2.7156
2.7170
Merkkijonovakio tulostettiin kuuden merkin levyiseen kenttn (muotoilukoodi A6). Muuttujan x arvo tulostettiin seitsemn merkin levyiseen kenttn
siten, ett desimaalipisteen oikealla puolella oli yksi numero (F7.1). Lauseke
(1 + 1/x)**x tulostettiin siten, ett desimaalipisteen oikealla puolella oli
nelj numeroa (F7.4).
3.14
Esimerkki: asuntolainan lyhennykset
Tasasuuruisin maksuin (annuiteetti) maksettavan lainan kuukausiert P

voidaan laskea lausekkeesta
P=
rL
,
1 (1 + r )m
miss
P = kuukausier
r = R/12, miss R = lainan vuosikorko
L = alkuperinen lainasumma
m = laina-aika kuukausina.
36
Fortran 95/2003
Teemme seuraavasti toimivan ohjelman:

1. luemme lainan vuosikoron prosentteina, alkuperisen lainasumman suuruuden markoissa sek laina-ajan pituuden kuukausina
2. tulostamme kyttjn antamat arvot
3. laskemme kuukausiern suuruuden
4. tulostamme kuukausiern suuruuden.
Seuraavassa on maksuern laskeva ohjelmakoodi:
PROGRAM annuiteetti
! Ohjelma laskee annuiteettilainan kuukausiern.
IMPLICIT NONE
REAL :: vuosikorko, kk_korko, lainasumma, kk_era
INTEGER :: laina_aika
WRITE (*,*) Anna vuosikorko prosentteina (%):
READ (*,*) vuosikorko
WRITE (*,*) Anna alkuperinen lainasumma (mk):
READ (*,*) lainasumma
WRITE (*,*) Anna laina-aika kuukausissa (kk):
READ (*,*) laina_aika
WRITE (*,*) Vuosikorko (%):, vuosikorko
WRITE (*,*) Lainasumma (mk):, lainasumma
WRITE (*,*) Laina-aika (kk):, laina_aika
kk_korko = (vuosikorko/100.0)/12.0
kk_era = kk_korko*lainasumma/ &
(1 - (1 + kk_korko)**(-laina_aika))
WRITE (*,*) Kuukausimaksu (mk):, kk_era
END PROGRAM annuiteetti
Varsinainen laskenta tehdn riveill

Kytmme tss jatkorivin merkki & osoittamaan, ett sijoituslause jatkuu

seuraavalle riville. Aluksi muutamme prosenteissa annetun vuosikoron kuukausikoroksi kk_korko. Tmn jlkeen laskemme kuukausiern suuruuden.
Huomaa sulkujen kytt!
Seuraavassa on esimerkki ohjelman kytst (muokkaamme tulostusta paremman nkiseksi jatkossa):
Anna vuosikorko prosentteina (%):
8.4
Anna alkuperinen lainasumma (mk):
100000
Anna laina-aika kuukausissa (kk):
36
Vuosikorko (%):
8.3999996
37
Lainasumma (mk):
1.0000000E+05
Laina-aika (kk): 36
Kuukausimaksu (mk):
3.1521265E+03
Ohjelma siis laski kuukausiern suuruudeksi noin 3152 mk.

Tulostuksessa on hiukan parantamisen varaa. Voimme kirjoittaa tulostuslauseet seuraavaan muotoon:
WRITE
WRITE
WRITE
WRITE
(*,(A20,
(*,(A20,
(*,(A20,
(*,(A20,
F12.2)) Vuosikorko (%):, vuosikorko

F12.2)) Lainasumma (mk):, lainasumma
I12)) Laina-aika (kk):, laina_aika
F12.2)) Kuukausimaksu (mk):, kk_era
Tss kytmme merkin * sijaan muotoilukoodia (A20, F12.2), joka tulostaa merkkijonoja 20 merkin levyiseen kenttn (koodi A20) sek reaalilukuja 12 merkin levyiseen kenttn kahden desimaalin tarkkuudella (koodi
F12.2). Koodi I12 puolestaan tulostaa kokonaislukuja 12 merkin levyiseen
kenttn.
Seuraavassa on esimerkki muutetun ohjelman tulostuksesta:
Vuosikorko (%):
Lainasumma (mk):
Laina-aika (kk):
Kuukausimaksu (mk):
8.40
100000.00
36
3152.13
Tulostus on nyt paljon luettavampaa!
3.15
Ehtolauseet
Fortranin IF-rakenne mahdollistaa ehdollisten toimintojen suorittamisen.

Seuraavassa kytmme IF-rakenteesta muotoa
IF (ehto) THEN
lohko1
ELSE
lohko2
END IF
Tietokone suorittaa lohkoon lohko1 kuuluvat lauseet siin tapauksessa, ett

loogisen lausekkeen ehto arvo on tosi. Muussa tapauksessa tietokone suorittaa lohkon lohko2.
Seuraavassa koodissa testaamme, etteivt kyttjn syttmt arvot ole virheellisi:
IF (vuosikorko > 0 .AND. lainasumma > 0 &
.AND. laina_aika > 0) THEN
! Sytttiedot ovat kunnossa
WRITE (*,(A20,F12.2)) Kuukausimaksu (mk):, kk_era
38
Fortran 95/2003
ELSE
WRITE (*,*) Virhe: arvojen pit olla positiivisia!
END IF
Vertailulausekkeen vuosikorko > 0 arvo on tosi, jos muuttujan arvo on

suurempi kuin nolla. Totuusarvot voimme yhdist operaattorilla .AND. seuraavasti:
lauseke1 .AND. lauseke2
Tmn lausekkeen arvo on tosi vain silloin, kun kumpikin argumentti on

tosi. Kerromme lis loogisista operaatioista luvussa 6 (sivu 67).
Esimerkin IF-lauseen ehto on tosi vain siin tapauksessa, ett kaikki testatuista muuttujista ovat positiivisia. Kun ehto on tosi, suoritetaan IF-lauseen
ensimminen lohko. Tllin lasketaan ja tulostetaan kuukausittainen maksuer. Muussa tapauksessa (ehto eptosi) suoritetaan IF-lauseen toinen lohko eli tulostetaan kyttjlle virheilmoitus.
3.16
Esimerkki: simulointitehtv
Seuraava tehtv liittyy komponenttien sijoitteluun shkpiirille. Ratkaisussa kytmme hyvksi edellisiss kappaleissa esiteltyj Fortran-kielen piirteit.
Sijoitamme yksikknelin kaksi satunnaista pistett a ja b. Pisteiden koordinaatit ovat a = (a1 , a2 ) ja b = (b1 , b2 ), joille siis ptevt epyhtlt
0 ai 1 ja 0 bi 1, i = 1, 2. Pisteiden vlimatka d on

d = (a1 b1 )2 + (a2 b2 )2 .
Tehtvn on arvioida, mik on etisyyden d odotusarvo E[d]. Kuva 3.1
havainnollistaa tehtv.
1
a

d = (a1 b1 )2 + (a2 b2 )2
d
b
0
1
Kuva 3.1: Simulointitehtvn geometrinen havainnollistus.
Voimme simuloida pisteiden sijoittamista ohjelmalla, joka sijoittaa satunnaisesti n pisteparia yksikknelin ja laskee keskiarvon pisteiden keskinisille etisyyksille:
39
PROGRAM pisteparit
! Ohjelma simuloi pisteparin sijoittamista
! yksikknelin.
IMPLICIT NONE
REAL, DIMENSION(2) :: a, b
REAL :: d, s = 0.0
INTEGER :: i, n
WRITE (*,*) Anna lukuparien lkm:
READ (*,*) n
WRITE (*,*) Pistepareja:, n, kpl
IF (n > 0) THEN
DO i = 1, n
CALL RANDOM_NUMBER(a)
CALL RANDOM_NUMBER(b)
s = s + SQRT(SUM((a - b)**2))
END DO
d = s/n
WRITE (*,*) Etisyyden keskiarvo:, d
ELSE
WRITE (*,*) Lukumr ei ole positiivinen!
END IF
END PROGRAM pisteparit
Pisteiden koordinaatit sijoitetaan kahden alkion reaalilukutaulukoihin a ja b.

Ohjelmakoodissa on muuttujamrittelyn yhteydess annettu muuttujalle s
alkuarvoksi nolla:
REAL :: d, s = 0.0
Ohjelma pyyt kyttjlt simuloitavien pisteparien lukumrn n. Tmn

jlkeen suoritetaan toistolausetta eli DO-silmukkaa n kertaa. Silmukkamuuttuja i ky jrjestyksess lpi arvot 1, 2, 3, . . . , n toistolauseen eri suorituskerroilla.
CALL-lauseella suoritetaan satunnaislukuja tuottava aliohjelmakutsu seuraavasti:
CALL RANDOM_NUMBER(muuttuja)
Aliohjelma RANDOM_NUMBER palauttaa argumentin muuttuja alkioissa tasajakautuneita satunnaislukuja vlilt [0, 1). Aliohjelman eroavat funktioista
siten, ett funktiolla on arvo, joka vlittyy kutsuvaan ohjelmayksikkn. Tavallisesti funktio vain laskee sille annetuista argumenteista jonkin tuloksen,
kun taas aliohjelman argumentit voivat olla sek lhttietoja ett muuttujia,
joiden kautta aliohjelma vlitt tuloksia kutsuvalle ohjelmayksiklle.
Rivill
s = s + SQRT(SUM((a - b)**2))
listn muuttujan s aikaisempaan arvoon uuden pisteparin etisyys.

Taulukko-operaatio a - b tarkoittaa taulukkojen alkioiden vlisten erotusten laskemista. Lauseke (a - b)**2 laskee alkioiden vlisten etisyyksien
nelit. Funktio SUM laskee tuloksena saadun taulukon arvot yhteen, ja funk-
40
Fortran 95/2003
tio SQRT laskee nelijuuren. Taulukko-operaatioista kerromme enemmn luvussa 11 (sivu 164).
Silmukan jlkeen laskemme etisyyksien keskiarvon d sijoituslauseessa
d = s/n
Seuraavassa on esimerkkej ohjelman kntmisest ja ajamisesta Unix-tietokoneella:

% f90 -o pisteparit pisteparit.f90
% ./pisteparit
Anna lukuparien lkm:
100
Pistepareja: 100 kpl
Etisyyden keskiarvo:
0.5217210
% ./pisteparit
Anna lukuparien lkm:
10000
Pistepareja: 10000 kpl
0.5244793
Etisyyksien keskiarvo nyttisi siis olevan noin 0.52. Tarkka odotusarvo on

(katso viitett [RR96])
E[d] =
3.17
1
1
ln(1 + 2) +
(2 + 2) 0.5214 . . .
3
15
Fortran-kielen moduulit
Kun ohjelma on vhnkin laajempi, kannattaa ohjelma jakaa moduuleihin,

joissa kussakin lasketaan jokin tarkasti rajattu laskentatehtvn osa. Moduulissa voidaan mritell mm. nimettyj vakioita, muuttujia, rakenteisia
tyyppej ja proseduureja. Samaa moduulia voidaan usein kytt hyvksi
muissakin yhteyksiss, joten ohjelmoijan tymr vhenee.
Ajatellaan esimerkkin lukuvlin [a, b] jakamista n osaan: (a, a + d, a +
2d, . . . , b d, b) miss d = |b a|/n on osavlien pituus. Ohjelmoimme
pistejoukon laskemista varten funktion nimelt jako, jota kutsutaan seuraavasti:
arvot = jako(a, b, n)
Tss argumentit a ja b ovat reaalilukuja ja argumentti n on kokonaisluku.

Funktio palauttaa arvonaan taulukon, jossa on n+1 alkiota. Voimme sijoittaa
funktion jako moduuliin nimelt taulukko_operaatiot:
MODULE taulukko_operaatiot
CONTAINS
FUNCTION jako(a, b, n)
IMPLICIT NONE
REAL :: a, b
INTEGER :: n
REAL, DIMENSION(n+1) :: jako
41
REAL :: pituus
INTEGER :: i
pituus = ABS(a-b)
jako = MIN(a,b) + (/ (i, i = 0, n) /)*pituus/n
END FUNCTION jako
END MODULE taulukko_operaatiot
Moduulin mrittely alkaa lauseella MODULE ja pttyy vastaavaan END-lauseeseen. Moduulin sisltm funktio jako kirjoitetaan CONTAINS-lauseen jlkeen.
Moduulissa on kytetty hyvksi Fortran 95:n uusia ominaisuuksia, jotka esitelln myhemmin luvuissa 9 (moduulit) ja 11 (taulukoiden ksittely). Funktion jako mrittelyss kytetty merkint
REAL, DIMENSION(n+1) :: jako
tarkoittaa, ett funktio palauttaa yksiulotteisen taulukon, jonka pituus riippuu argumentista n.
Voimme kytt edell mritelty moduulia seuraavasti:
PROGRAM jakaminen
USE taulukko_operaatiot
IMPLICIT NONE
INTEGER, PARAMETER :: n = 5
REAL, DIMENSION(n+1) :: arvot
REAL :: pii
pii = 4*ATAN(1.0)
arvot = jako(0.0, pii, n)
WRITE (*,*) arvot: , arvot
WRITE (*,*) SIN(arvot): , SIN(arvot)
END PROGRAM jakaminen
Otimme kyttn moduulin taulukko_operaatiot komennolla USE, jonka

on oltava heti ohjelmayksikn alussa. Lauseen ansiosta saamme kyttmme moduulissa mritellyn funktion jako.
Ohjelmassa kytetn Fortranin standardifunktiota ATAN piin likiarvon laskemiseen. Vli [0, ] jaetaan osiin moduulissa taulukko_operaatiot mritellyll funktiolla jako. Funktio SIN laskee sinifunktion arvot jakopisteiss.
Ohjelmamme voidaan knt kahdessa vaiheessa. Ensiksi knnmme moduulin, joka on tiedostossa taulukko_operaatiot.90:
% f90 -c taulukko_operaatiot.f90
Tmn jlkeen knnmme pohjelman tiedostosta jakaminen.f90 ja linkitmme ohjelmaan kyttmmme moduulin:
% f90 jakaminen.f90 taulukko_operaatiot.o
Tmn jlkeen voimme testata ohjelmaamme:

% ./a.out
arvot:
0.0000000E+00 0.6283185
1.256637
1.884956
2.513274
3.141593
42
Fortran 95/2003
SIN(arvot):
0.9510565
0.0000000E+00
0.5877852
0.5877852
0.9510565
-8.7422777E-08
Ohjelma siis jakoi lukuvlin [0, ] viiteen osavliin ja tulosti jakopisteet

sek sin-funktion arvot niss pisteiss.
3.18
Listietoja
Seuraavissa luvuissa kerromme tarkemmin tss luvussa esitellyist Fortran-kielen piirteist. Ksittelemme mm. funktioita ja aliohjelmia, moduuleita, taulukkoja sek rakenteisia tietotyypej. Luvussa 15 (sivu 275) kerromme
Fortranin vanhentuvista ja vltettvist piirteist.
3.19
Yhteenveto
Fortran on eniten kytetty kieli tieteellisess ja teknisess laskennassa.

Fortran-kieliset ohjelmat voi laajasti kytss olevan standardin ansiosta siirt melkein mille tahansa tietokoneelle.
Fortranin tulostus- ja syttlauseet ovat WRITE ja READ.
Muuttujatyypill INTEGER ksitelln kokonaislukuja ja tyypill REAL
ksitelln reaalilukuja. Muuttujatyyppi CHARACTER kytetn merkkijonojen mrittelyyn.
Fortran-kielen standardiproseduurien lisksi voit mritell omia funktioita ja aliohjelmia.
Voit ohjata ohjelman suoritusta DO-silmukan ja IF-lauseen avulla.
Kyt moduuleja ohjelmakoodin jakamiseen helpommin hallittaviin ja
yllpidettviin osiin.
Harjoitustehtvi
1. Kuinka vanha ohjelmointikieli Fortran on tll hetkell?
2. Jos tunnet ennestn Fortran-kielt, etsi kappaleen 1.2 (sivu 13) esimerkist Fortran-kielen uusia piirteit (verrattuna FORTRAN 77 -kieleen).
3. Kirjoita ohjelma, joka laskee sinifunktion SIN(x) arvot pisteiss
{0, /8, 2 /8, . . . , }.
43
4. Muuta edellist ohjelmaa siten, ett arvot lasketaan pisteiss

{ , 9 /10, 8 /10, . . . , 0, . . . , }.
5. Mrittele seuraava ohjelma:
luetaan kolmion sivujen pituudet a, b, c
lasketaan kolmion pinta-ala A kaavasta

A = p(p a)(p b)(p c),
miss p = (a + b + c)/2
tulostetaan sivujen pituudet ja pinta-ala.
Laske pinta-ala kolmiolle, jonka sivujen pituudet ovat 3, 4 ja 5. Mit
ohjelma tekee, jos sivujen pituudet ovat 3, 4 ja 8? Mik menee pieleen?
6. Testaa edellisess esimerkiss kyttjn antaman syttdatan jrkevyys. Tutki lisksi nelijuuren sisll olevan lausekkeen merkki, ja ilmoita virheest, jos arvo on negatiivinen.
7. Muuta kappaleen 3.14 asuntolainaesimerkki siten, ett kuukausiern
lisksi tulostetaan kuukausittain jljell oleva lainapoma. Huomaa,
ett kuukausiern sisltyy sek lainan korkoa ett lyhennyst. Korko
oletetaan vakioksi laina-ajalla.
8. Muuta kappaleen 3.16 simulointiesimerkki siten, ett mritelmn

d = (a1 b1 )2 + (a2 b2 )2
sijaan etisyyden d laskemiseen kytetn maksiminormia:
d = max |ai bi |.
i{1,2}
9. Muuta kappaleen 3.16 simulointiesimerkki siten, ett etisyyksien dj

keskiarvon lisksi lasketaan mys keskihajonta . Kyt apuna kaavoja
n
=
j=1
dj
n
,
j=1
d2j n 2
n1
Siis saat laskettua keskihajonnan laskemalla etisyyksien neliiden summan.

10. Muuta kappaleen 3.16 simulointiesimerkki siten, ett yksikknelin
sijasta pisteparit sijoitetaan suorakulmioon, jonka sivujen pituudet ovat
(1, t), t 0. Mit saat etisyyden odotusarvoksi, kun t = 0 tai kun t on
hyvin suuri?
11. Toteuta kappaleen 3.16 simulointiesimerkki yksikknelin sijaan yksikkkuutiossa eli kolmiulotteisessa tapauksessa.
44
Fortran 95/2003
Ohjelman perusrakenne
Esittelemme tss luvussa Fortran 95 -ohjelmakoodin rakenteen ja perussyntaksin. Keskitymme esityksess Fortran 95 -standardin mukaiseen lhdekoodin esitystapaan.
4.1
Lhdekoodin muoto
Fortran-kntj ksittelee ohjelmakoodia sisltvi lhdekooditiedostoja.

Seuraavassa kuvataan Fortran 95:n vapaata lhdekoodin muotoa (free source
form). Aiemmissa Fortranin versioissa kytettiin tst poikkeavaa sarakesidonnaista lhdekoodin muotoa (xed source form), joka periytyi reikkorttien aikakaudelta. Sarakesidonnaisen lhdekoodin muodon muuttamista vapaaseen muotoon kuvataan luvussa 15 (sivu 275).
Fortran-ohjelma koostuu jonosta lauseita. Lauseet kirjoitetaan riveille, joiden pituus voi olla 0 . . . 132 merkki. Lausetta voi jatkaa seuraavalle riville
kyttmll jatkorivin merkki & seuraavasti:
Jos merkin & jlkeen rivin lopussa on vlilyntej, ne jtetn huomiotta.

Jatkorivi kannattaa sisent vlilynneill tss esitettyyn tapaan ohjelmakoodin selkeyttmiseksi. Rivill saa olla jatkorivej korkeintaan 39.
Jos merkkijono halutaan jatkaa usealle riville, voi jatkorivin alkuun sijoittaa
vlilyntej sek merkin &, jolloin merkkijono jatkuu vasta tst kohtaa:
WRITE (*,*) "Tm on todella pitk & monimutkainen&
& merkkijono."
Merkki & ksitetn rivin jatkamisen tunnukseksi vain rivin lopussa, joten
edellinen lause tulostaa ensimmisen &-merkin:
Tm on todella pitk & monimutkainen merkkijono.
Riville voi laittaa useamman lauseen erottamalla ne puolipisteell (;):

x = 1.0; b = 1.0
Rivin lopussa ei tarvita puolipistett, koska rivin loppu automaattisesti lopettaa lauseen. Puolipisteen kytt kannattaa vltt, sill turha tiivistmi-
4. Ohjelman perusrakenne
45
nen (rivimrn minimointi) johtaa vaikeasti luettavaan koodiin. Sen sijaan

tyhji rivej kannattaa kytt ryhmittelemn ohjelmayksikn eri osia.
Ohjelmakoodiin kannattaa sijoittaa ohjelman toimintaa kuvaavia kommentteja, jotka aloitetaan huutomerkill (!):
PROGRAM mahtava
! Tm ohjelma ratkaisee maailmankaikkeuden perusyhtlt
! kytten 10-ulotteista supersieteoriaa.
Kommentteja voi sijoittaa mys jatketun rivin loppuun:

REAL :: nopeus = 0.0, &
! raketin nopeus alussa (m/s)
kiihtyvyys = 24.0 ! raketin kiihtyvyys (m/s**2)
Tss kerrottiin ohjelmassa kytettyjen muuttujien mrittelyn yhteydess

muuttujien merkitys.
Jos kommenttimerkki on merkkijonon sisll, se tulkitaan osaksi merkkijonoa.
Vlilynnit ovat merkitsevi Fortran 95 -kielen vapaassa lhdekoodin muodossa. Yht tai useampaa vlilynti kytetn erottamaan tunnuksia toisistaan. Pohjelman voi aloittaa vaikkapa seuraavilla tavoilla:
PROGRAM omaohjelma
PROGRAM
omaohjelma
Seuraava ei ole laillista vapaassa lhdekoodin muodossa:

PROGRAMomaohjelma
Kukaan tuskin haluaisikaan kirjoittaa tllaista koodia.

Useimmat Fortranin avainsanat eivt sisll vlilyntej, mutta poikkeuksen
muodostavat ohjelmayksikiden ja ohjausrakenteiden lopetuslauseet:
END PROGRAM omaohjelma
END DO
END IF
Omissa ohjelmayksikiden, muuttujien jne. tunnuksissa ei saa kytt vlilyntej.
4.2 Fortranin merkkivalikoima

Fortran 95 -kielen tunnuksen tulee alkaa kirjaimella. Pienet kirjaimet ovat
valinnaisesti osa merkkivalikoimaa, ja niiden merkitys ohjelmakoodin tunnuksissa on sama kuin isojen kirjainten.
Kytnnss kaikki Fortran-kntjt hyvksyvt pienet kirjaimet, vaikka
tm ei olekaan vlttmtnt. Tss teoksessa on kytetty isoja kirjaimia
Fortranin valmiiden tunnusten nimiss ja pieni kirjaimia itse mritellyiss
tunnuksissa.
46
Fortran 95/2003
Tunnuksissa kytettvien merkkien lisksi Fortran-kieleen kuuluu muutamia muita symboleita. Fortranin erikoismerkit on lueteltu taulukossa 4.1.
Taulukko 4.1: Fortranin erikoismerkit.
Merkki
Selitys
Merkki
Selitys
=
+
*
/
(
)
,
.
vlilynti
yhtlisyysmerkki
plusmerkki
miinusmerkki
asteriski
vinoviiva
oikea sulje
vasen sulje
pilkku
piste
heittomerkki
:
!
"
%
&
;
<
>
?
$
kaksoispiste
huutomerkki
lainausmerkki
prosenttimerkki
et-merkki
puolipiste
pienempi kuin -merkki
suurempi kuin -merkki
kysymysmerkki
dollarin merkki
Kaikki taulukossa 4.1 esitetyt merkit sisltyvt ASCII-merkistn (liite D

sivulla 324). Merkkijonoissa ja kommenteissa voi olla mahdollista kytt
mys muita erikoismerkkej, vaikkapa skandinaavisia kirjaimia , jne.
Yleens Fortran-kntj tukee niit merkistj mit tietokoneessa muutenkin kytetn.
4.3
Muuttujien ja vakioiden nimet
Muuttujien ja vakioiden nimien tulee alkaa kirjaimella, ja nimen maksimipituus on 31 merkki. Seuraavassa on esimerkkej laillisista nimist: a, a2,
a_2 ja a_b_c. Sen sijaan seuraavat nimet eivt ky: 2a, _a ja a b.
Fortran-kieless ei ole ns. varattuja sanoja, joten mys Fortranin tunnukset
voi mritell vaikkapa omien muuttujien nimiksi. Tm ei kuitenkaan ole
suositeltavaa!
PROGRAM crazy
IMPLICIT NONE
REAL :: sin, max = 1.0, real = 1.23
INTEGER :: program, precision
sin = max + real
program = 12
precision = 10
END PROGRAM crazy
Tss esimerkiss eivt Fortranin sisnrakennetut funktiot SIN, MAX ja

PRECISION ole en kytettviss, koska nimet on varattu ohjelman muuttujille sin, max ja precision.
47
4.4 Ohjelmakoodin lauseiden jrjestys

Trkeimmt Fortran-kielen lauseet voidaan jakaa seuraaviin tyyppeihin:
ohjelmayksikn otsikkolauseet:
PROGRAM, FUNCTION, SUBROUTINE ja MODULE
kommentit
USE-lauseet
lause IMPLICIT NONE
tyyppien, muuttujien ja nimettyjen vakioiden mrittelyt
kutsumuodon mrittelyt INTERFACE-lohkossa
muut mrittelylauseet: EXTERNAL, INTRINSIC, OPTIONAL jne.
FORMAT-lauseet
suoritettavat lauseet ja rakenteet
CONTAINS-lause
ohjelmayksikon lopettava END-lause.
Kukin ohjelmayksikk alkaa otsikkolauseella (PROGRAM, FUNCTION jne.) ja
pttyy vastaavaan END-lauseeseen. Ohjelmayksikn sisll lauseet voivat
esiinty kuvan 4.1 havainnollistamassa jrjestyksess. Kuvaan ei ole otettu
mukaan vanhaa BLOCK DATA -rakennetta, jonka voi korvata moduulilla.
PROGRAM-, FUNCTION-, SUBROUTINE- tai MODULE-lause
USE-lauseet
IMPLICIT NONE -lause
FORMAT-lauseet
vakioiden mrittelyt
tyyppien ja muuttujien mrittelyt

INTERFACE-lohkot
suoritettavat lauseet ja rakenteet

CONTAINS-lause
sisiset tai moduulin proseduurit
ohjelmayksikn pttv END-lause
Kuva 4.1: Fortran 95:n lauseiden jrjestys ohjelmayksikss.
Seuraava ohjelma havainnollistaa Fortranin pohjelman omaohjelma ja sisisen funktion f rakennetta:
48
Fortran 95/2003
PROGRAM omaohjelma
! Ohjelma laskee lausekkeen a**i + b**j arvon.
IMPLICIT NONE
REAL :: a, b
INTEGER :: i, j
WRITE (*,*) Anna a ja b:
READ (*,*) a, b
WRITE (*,*) Anna i ja j:
READ (*,*) i, j
WRITE (*,*) f(x) = , f(a, i, b, j)
CONTAINS
FUNCTION f(x, x_potenssi, y, y_potenssi) RESULT(f_arvo)
IMPLICIT NONE
REAL :: x, y
INTEGER :: x_potenssi, y_potenssi
REAL :: f_arvo
f_arvo = x**x_potenssi + y**y_potenssi
END FUNCTION f
END PROGRAM omaohjelma
Pohjelman sisinen funktio f mritelln CONTAINS-lauseen jlkeen. Sisisill funktiolla ei voi olla omia sisisi funktioita tai aliohjelmia. Funktioiden mrittely ksitelln tarkemmin luvussa 8 (sivu 99).
4.5
INCLUDE-lause ja moduulit
Fortran 95:ss voidaan ohjelmakoodiin sisllytt toisessa tiedostossa olevia

mrittelyj kyttmll INCLUDE-lausetta:
PROGRAM sisalto
IMPLICIT NONE
INCLUDE vakiot.inc
REAL :: x = pii
WRITE (*,*) Piin arvo: , x
END PROGRAM sisalto
Tiedoston vakiot.inc sislt voisi olla seuraava:

REAL, PARAMETER :: pii = 3.14159265358979
Ohjelmamme siis tulostaa :n arvon.

INCLUDE-lauseiden sijaan kannattaa kytt moduuleita ja USE-lausetta. Etuna tst on mm. parempi knnsaikainen virheiden tarkistus. Seuraavassa
on esimerkki moduulin vakiot kytst:
PROGRAM sisalto
USE vakiot ! Trkeit matematiikan vakioita
IMPLICIT NONE
REAL :: x = pii
WRITE (*,*) Piin arvo: , x
END PROGRAM sisalto
49
Edellisess pohjelmassa kytetty moduuli vakiot voitaisiin mritell

seuraavasti:
MODULE vakiot
IMPLICIT NONE
REAL, PARAMETER :: &
pii = 3.14159265358979, &
e = 2.71828182845905
END MODULE vakiot
Moduuleissa voi mritell muuttujien ja vakioiden lisksi mm. proseduureja. Lyhyt esimerkki tst lytyy kappaleesta 3.17 sivulta 40. Kerromme
moduulien kytst enemmn luvussa 9 (sivu 126).
4.6 Yhteenveto
Voit kirjoittaa ohjelmakoodin 132 merkin pituisille riveille. Kytettviss on lisksi jatkorivit (&), kommentit (!) ja mahdollisuus sijoittaa useita
lauseita riville (;).
Tunnukset muodostuvat kirjaimista A, . . . Z, numeroista 0, 1, . . . , 9
sek alaviivasta _. Tunnuksen tulee alkaa kirjaimella. Pienten kirjainten
merkitys tunnuksissa on sama kuin isojen kirjainten.
Kyt vlilyntej erottamaan tunnukset ja lausekkeiden osat toisistaan.
Aloita ohjelmayksikk otsikkolauseella PROGRAM, MODULE, FUNCTION ja
SUBROUTINE. Pt ohjelmayksikk vastaavaan END-lauseeseen.
Kyt moduuleja ohjelmayksikkjen jsentelyyn.
Harjoitustehtvi
1. Mit seuraava koodirivi tekee?
a = 0.0 ; b = 370 ! Alustus ; c = 17.0 ; d = 33.0
2. Onko seuraava oikein kirjoitettua Fortran 90 -koodia?

y = SIN(MAX(x1,x2)) * EXP(-COS(x3)**i) - TAN(AT&
& AN(x4))
3. Onko seuraava mrittely oikein?

REAL :: real; REAL :: price
4. Selvit itsellesi, mit kappaleessa 4.4 esitetty pohjelma tekee (knn

ohjelma ja aja se).
5. Ovatko seuraavat Fortranin lauseet kirjoitettu oikein?
50
Fortran 95/2003
merkkijono = Aamun virkku,

& illan torkku.
x = 0.4-6
vastaus = Tosi & eptosi
ala-raja = 0.0005E10
y = E6
6. Etsi seuraavasta ohjelmakoodista kaikki virheet.

PROGARM testaus_ohjelma
IMPLICIT NONE
INTEGER :: i
REAL :: pi = 3*ARCTAN(1.0)
WRITE (*,*) pii on pii
i = 4
j = 10.0 - i
WRITE (*,*) "i/(10-i):, i/j
END PROGRAM testaus_ohelma
7. Kokeile kappaleessa 4.5 esitetyn moduulin vakiot kytt. Lis moduuliin muita matemaattisia ja luonnonvakioita.
5. Perustyypit
51
Perustyypit
Esittelemme tss luvussa Fortranin perustyyppien kytt. Nit kutsutaan

mys nimell standardityypit. Esittelemme rakenteiset tietotyypit myhemmin luvussa 10 (sivu 152). Taulukoiden kytst kerromme luvussa 11
(sivu 164).
5.1 Perustyypit ja vakiot

Tietokoneohjelmilla ksitelln tieto-olioita, jotka rakentuvat luvuista ja
merkkijonoista sek niden yhdistelmist. Fortran sislt viisi perustyyppi
(intrinsic type):
kokonaisluvut (INTEGER)
reaaliluvut (REAL)
kompleksiluvut (COMPLEX)
totuusarvot (LOGICAL)
merkkijonot (CHARACTER).
Nit tietotyyppej ksitelln Fortran-kielen operaatioilla, proseduureilla
ja lauseilla.
5.1.1 Kokonaisluvut
Kokonaislukutyypill esitetn positiivisia tai negatiivisia kokonaislukuja eli
joukon {. . . , 2, 1, 0, 1, 2, . . . } alkioita. Fortranin kokonaislukutyypill voi
esitt vain rellisen osajoukon kokonaisluvuista.
Ohjelmassa voi esiinty kokonaislukuvakioita, jotka koostuvat numeroista
0, 1, . . . , 9:
WRITE (*,*) 40 + 2
Tss vakiot 40 ja 2 lasketaan yhteen tulostusta varten.
52
Fortran 95/2003
Edell luetelluista perustyypeist voi olla kytettviss eri lajeja (kind).

Kaikki Fortran-toteutukset tuntevat ainakin yhden kokonaislukulajin (integer kind). Monissa toteutuksissa on kuitenkin useita eri lajeja kokonaislukuja. Lajimreist kerrotaan kappaleessa 5.5 sivulla 56.
Kutakin kokonaislukulajia vastaa sill esitettviss olevien kokonaislukujen
joukko, joka tyypillisesti koostuu luvuista {m, m + 1, . . . , m 2, m 1}.
Tss m on kokonaisluvun lajista riippuva luku, esimerkiksi 231 tai 263 .
5.1.2 Reaaliluvut
Fortran-kielen reaaliluvut ovat kokonaislukutyypin tapaan vain rellinen
osajoukko todellisista reaaliluvuista.
Reaalilukuvakiot erotetaan kokonaislukuvakioista desimaalipisteen tai eksponenttinotaation avulla:
WRITE (*,*) 42.0, 0.42E2, 0.012345, 12345E-6
Yksinkertaisen desimaalinotaation lisksi reaalilukuvakiot voidaan siis esitt eksponenttimuodossa. Vakio 0.42E2 tarkoittaa reaalilukua 0.42 102 =
42.0 ja vakio 12345E-6 tarkoittaa reaalilukua 12345 106 = 0.012345.
Edellisen lauseen tulostus voisi olla
42.0000000
42.0000000
1.2345000E-02
1.2345000E-02
Reaalilukutyypist on vhintn kaksi eri lajia. Lajimreist kerrotaan kappaleessa 5.5 sivulla 56.
5.1.3 Kompleksiluvut
Kompleksilukutyyppi vastaa matemaattista kompleksiluvun ksitett. Siten
kompleksiluku
z koostuu reaaliosasta x ja imaginriosasta y eli z = x+iy,
miss i = 1.
Kompleksilukuvakiot kirjoitetaan sulkujen sisn:
WRITE (*,*) (0, -1)*(1.2345E-2, 8)
Tss lasketaan kompleksilukujen 1.0i ja 0.012345 + 8.0i tulo. Tulostus

voisi nytt tlt:
(8.000000,-1.2345000E-02)
Jos kummatkin sulkujen sisss olevat luvut ovat kokonaislukutyyppi, vakio on oletuslajin kompleksiluku. Jos sulkujen sisll on reaalilukuja, on
kompleksiluku suuremman tarkkuuden reaaliluvun mukaista lajia.
5.1.4 Totuusarvot
Fortranissa voidaan esitt totuusarvot tosi ja eptosi vakioilla .TRUE. ja
.FALSE.. Vakioiden alussa ja lopussa olevat pisteet ovat tarpeen!
5. Perustyypit
53
Totuusarvoja voi ksitell loogisilla operaatioilla .NOT., .AND., .OR., .EQV.

ja .NEQV.. Totuusarvojen ksittelyst kerrotaan enemmn sivulla 76.
5.1.5 Merkkijonot
Merkkijonotyypill voidaan esitt merkkijonoja. Merkkijonovakio sijoitetaan ohjelmakoodiin yksinkertaisten tai kaksinkertaisten lainausmerkkien
sisn:
WRITE (*,*) "kki ern pivn..."
WRITE (*,*) kki ern pivn...
Lainausmerkki voidaan sisllytt osaksi merkkijonoa sijoittamalla se toisentyyppisiin lainausmerkkeihin tai kahdentamalla se:
WRITE (*,*) "Yhtkki tuli pime."
WRITE (*,*) Yhtkki tuli pime.
Merkkijonoja voidaan liitt perkkin liitosoperaatiolla // seuraavasti:

WRITE (*,*) Yksi // // kaksi
Tss tulostettiin merkkijono Yksi kaksi.
5.2 Muuttujien mrittely

Muuttujat esitelln ohjelmayksikn alussa ennen suoritettavia lauseita.
Muuttujat voivat olla Fortranin sisisi tietotyyppej tai nist johdettuja
tyyppej.
Muuttujan mrittelylause koostuu tyypinmrittelyst ja listasta muuttujien nimi. Mrittelemme seuraavassa kolme kokonaislukumuuttujaa ja yhden merkkijonon, jonka pituus on kymmenen merkki:
INTEGER :: luku, alku, loppu
CHARACTER (LEN=10) :: merkkijono
Tyypinmrittely voi koostua pilkuilla erotetusta listasta tyyppi koskevia

mreit. Jos nit mreit ei ole (kuten edell), voi mrittelyst jtt
osan :: pois. Suosittelemme kuitenkin edell esitty mrittelytapaa, koska
tllin on tarvittaessa helppo list mreit tyypin tunnuksen pern.
Seuraava esimerkkiohjelma lukee ptteelt reaali- ja kokonaisluvut x ja n,
ja tulostaa lausekkeen x n arvon:
PROGRAM syotto
IMPLICIT NONE
REAL :: x
INTEGER :: n
WRITE (*,*) Anna x ja n:
READ (*,*) x, n
54
Fortran 95/2003
WRITE (*,*) x**n = , x**n

END PROGRAM syotto
Ohjelmassa mritelln reaalilukumuuttuja x ja kokonaislukumuuttuja n.

Seuraavassa on esimerkki ohjelman ajamisesta:
Anna x ja n:
1.2345 3
x**n =
1.8813663
Muuttujalle voidaan antaa alkuarvo alustuslausekkeessa (initialization expression) seuraavaan tapaan:

PROGRAM muuttujat
IMPLICIT NONE
LOGICAL :: tulosta = .TRUE.
COMPLEX :: z = (0.5, 1.0)
CHARACTER (LEN=20) :: selitys = Kompleksiluku:
IF (tulosta) THEN
WRITE (*,*) selitys, z
END IF
END PROGRAM muuttujat
Loogisen muuttujan tulosta arvoksi asetetaan tosi. Kompleksilukumuuttuja z sai alkuarvoksi luvun 0.5 + 1.0i.
Merkkijonomuuttujassa selitys on 20 merkki. Alustuslausekkeessa
CHARACTER (LEN=20) :: selitys = Kompleksiluku:
sijoituslauseen oikea puoli on lyhyempi, ja tllin kntj lis merkkijonon selitys loppuun tarpeellisen mrn vlilyntej.
Ohjelman tulostus voisi nytt tlt:
Kompleksiluku:
(0.5000000000,1.000000000)
Alustuslausekkeissa saa kytt vakioita ja peruslaskutoimituksia sek

osaa standardifunktioista. Esimerkiksi potenssiinkorotusoperaatiota (**)
saa kytt vain, jos potenssi on kokonaisluku. Alkioittaisen standardifunktion (esimerkkin MAX ja LEN) argumentti ja palautettava arvo saa olla
kokonaisluku- tai merkkijonotyyppi. Esimerkiksi funktiota SIN ei voi kytt alustuslausekkeessa.
5.3
Nimetyt vakiot
Edellisess esimerkiss mrittelimme joukon muuttujia, joiden alkuarvot

annoimme mrittelylauseessa. Muuttujien sijaan voimme mritell nimettyj vakioita, joiden arvoa ei voi muuttaa ohjelman ajon aikana.
Nimetyill vakioilla kannattaa korvata ohjelmakoodissa useassa kohdassa
esiintyvi luku- ym. vakioita. Tllin ohjelmakoodin muuttaminen on helpompaa. Riitt, ett nimetyn vakion mrittely muutetaan.
5. Perustyypit
55
Nimetyt vakiot erotetaan muuttujista mreen PARAMETER avulla. Seuraavassa kytmme hyvksi nimettyj vakioita kehote ja tuloste:
PROGRAM liittolainen
IMPLICIT NONE
CHARACTER (LEN=*), PARAMETER :: &
kehote = Syt kompleksiluku z:, &
tuloste = Luku z ja SIN(z):
COMPLEX :: z
WRITE (*,*) kehote
READ (*,*) z
WRITE (*,*) tuloste, z, SIN(z)
END PROGRAM liittolainen
Tss mrittelimme ohjelman tulostaman kehotteen ja selitteen merkkijonovakioiksi. Ohjelman kytt nytt seuraavalta:
Syt kompleksiluku:
(0.5, 1.0)
Luku z ja SIN(z): (0.5000000,1.000000) (0.7397923,1.031336)
Merkkijonovakion kehote pituudeksi tulee mrittelyn (LEN=*) ansiosta

merkkijonon Syt kompleksiluku z: pituus eli siis 22 merkki. Merkkijonovakion tuloste pituus on puolestaan 17 merkki.
Jos nimetylle vakiolle yritetn antaa uusi arvo ohjelmassa, ilmoittaa kntj virheellisest koodista.
Esimerkiksi mriteltess vakiokokoisia taulukkoja on taulukkojen koot
hyv mritell nimetyiksi vakioiksi:
REAL, DIMENSION(n) :: b
REAL, DIMENSION(n,n) :: c, d
Tss mritelty nimetty vakiota n voi kytt mys DO-silmukan toistokertojen mrmiseen:
INTEGER :: i, j
DO i = 1, n
DO j = 1, n
d(j,i) = 1.0 - c(j,i)
END DO
END DO
Jos haluamme muuttaa tmn esimerkin taulukkojen b, c ja d kokoa, selvimme tst muuttamalla nimetyn vakion n mrittely.
5.4 IMPLICIT NONE ja alkukirjainsnt

Vanhoissa Fortran-koodeissa on kytetty hyvksi muuttujien alkukirjainsnt (implicit typing), jolloin muuttujan tyypin mrsi tunnuksen en-
56
Fortran 95/2003
simminen kirjain. Muuttujat, joiden ensimminen kirjain oli I . . . N, olivat

kokonaislukuja. Kaikki muut muuttujat olivat reaalilukuja.
Alkukirjainsnnn kytll vltettiin muuttujien tyypin mrittely ohjelmayksikn alussa. Valitettavasti tm voi johtaa erittin hankalasti jljitettviin virhetilanteisiin. Jos muuttujan mrittely unohtuu, saattaa tuloksena olla vrn tyyppinen muuttuja. Toinen virhelhde ovat kirjoitusvirheet
tunnusten nimiss: tuloksena on uusi muuttuja, jonka tyypin mr alkukirjainsnt. Alkukirjainsnnn kytt tuottaakin epselv ja vaikeasti
yllpidettv koodia.
Ohjelmayksikn alkuun onkin syyt aina laittaa lause
IMPLICIT NONE
Ainoastaan USE-lause sijoitetaan ennen IMPLICIT-lausetta.

Lause IMPLICIT NONE kytkee alkukirjainsnnn pois kytst. Tllin kntj tarkistaa, ett jokainen tunnus on mritelty. Vrin kirjoitetut muuttujien nimet paljastuvat siten usein jo knnsaikana.
5.5
Perustyyppien lajimreet
Tietokoneiden prosessorit mahdollistavat laskemisen usean eri tarkkuuden

kokonais- ja reaaliluvuilla. Tarkkuuksia on kytettviss yleens kaksi tai
kolme erilaista. Fortran-kielen lajiparametrien avulla on helppo valita ohjelmassa kytettv laskentatarkkuus. Lisksi lajiparametrit mahdollistavat
laskentatarkkuuden silymisen siirrettess ohjelma toiseen koneeseen.
Fortranin perustyyppeihin voidaan liitt lajimre (kind), joka kertoo, millaisen version tyypist haluamme kyttn esimerkiksi mik on reaalilukujen haluttu esitystarkkuus ja lukualue. Tllaisia mrittelyj kutsutaan
parametrisoiduiksi tyyppimrittelyiksi. Numeeristen tyyppien eri lajit liittyvt yleens lukujen tarkkuuteen. Merkkijonojen lajit liittyvt vaikkapa kiinalaisten kirjoitusmerkkien kyttn: kytetty laitteisto voi normaalin ASCIImerkistn lisksi tukea muitakin merkkijonolajeja.
Lajiparametri annetaan osana muuttujan mrittely esimerkiksi seuraavasti:
REAL (KIND=lajiparametri) :: x
INTEGER (KIND=lajiparametri) :: i
COMPLEX (KIND=lajiparametri) :: z
LOGICAL (KIND=lajiparametri) :: testi
CHARACTER (LEN=80, KIND=lajiparametri) :: rivi
Lajiparametri on Fortran-kntjst riippuva positiivinen kokonaislukuvakio, joka kannattaa selvitt tarkoitukseen varatuilla funktiokutsuilla (esimerkiksi SELECTED_INT_KIND).
5. Perustyypit
57
5.5.1 Kokonaisluvut
Kokonaislukujen lajiparametri mr luvun esitystarkkuuden. Funktiokutsu
SELECTED_INT_KIND(r)
tuottaa lajiparametrin arvon sellaisille kokonaisluvuille i, joiden arvo saa

vaihdella vlill 10r < i < 10r .
Lajiparametrin arvo kannattaa mritell nimetyksi kokonaislukuvakioksi
seuraavaan tapaan:
INTEGER, PARAMETER :: isoluku = SELECTED_INT_KIND(9)
INTEGER (KIND=isoluku) :: m, n
INTEGER (KIND=isoluku), PARAMETER :: max_iter = 10000000
Edell mritellyll kokonaislukulajilla isoluku voidaan esitt vhintn

sellaiset kokonaisluvut, joissa on 9 desimaalinumeroa.
Jos haluttua tarkkuutta ei ole kytettviss, palauttaa funktiokutsu
SELECTED_INT_KIND lajiparametrille negatiivisen arvon. Jos tt arvoa yritetn kytt muuttujien parametrisoiduissa mrittelyiss, saadaan knnsaikainen virhe.
Kokonaislukuvakion lajiparametri voidaan list kokonaislukuvakion pern alaviivan jlkeen:
WRITE (*,*) 199600000_isoluku
5.5.2 Reaaliluvut
Reaalilukujen tarkkuuden voi valita samaan tapaan kuin kokonaislukujenkin. Tarkkuuden mrittelyss oletetaan, ett reaaliluvut esitetn kytten
eksponenttinotaatiota
d.ddddd 10e ,
miss mantissassa d.ddddd on p merkitsev desimaalia ja eksponentin e
vaihteluvli on r e r . Tllaista reaalilukuesityst kutsutaan liukulukuesitykseksi.
Liukulukujen lajiparametrin voi valita funktiokutsulla
SELECTED_REAL_KIND(p,r)
Tss p on liukuluvun tarkkuus desimaalinumeroina ja r on eksponentin

vaihteluvli.
Jos halutaan esitt reaalilukuja, joiden eksponentin vaihteluvli on vhintn 30 ja joiden mantissassa on ainakin kuusi merkitsev desimaalia,
saadaan sopiva lajiparametri selville funktiokutsulla
SELECTED_REAL_KIND(6, 30)
58
Fortran 95/2003
Saatu lajiparametrin arvo takaa, ett kyseisen lajin reaaliluvulla voidaan esitt vhintn halutun tarkkuuden ja eksponentin vaihteluvlin reaaliluvut.
Fortran-kntj tuntee ainakin kaksi eri lajia reaalilukuja. Oletuksena on
pienemmn tarkkuuden reaaliluvut. Reaalilukuvakion laji voidaan ilmoittaa
lismll vakion pern alaviiva ja lajiparametri samoin kuin kokonaisluvuillekin:
WRITE (*,*) 3.141592653589793_reaalilukulaji
Lisksi on kytettviss standardifunktio KIND, joka palauttaa tunnusta vastaavat tietotyypin lajiparametrin. Seuraavassa on esimerkki funktion kytst:
INTEGER :: i
REAL :: x
x = REAL(i, KIND=KIND(x))
Tss muutettiin kokonaislukumuuttujan i arvo muuttujan x lajia vastaavaksi reaaliluvuksi kyttmll funktiota REAL.
Kompleksiluvun lajimre ilmaisee sen reaali- ja imaginriosan lajin samoin
kuin reaaliluvuille:
INTEGER, PARAMETER :: tarkka = SELECTED_REAL_KIND(10,100)
COMPLEX (KIND=tarkka) :: z
5.5.4 Merkkijonot ja totuusarvot

Yleens tyypille LOGICAL kytetn oletuslajin tyyppi, samoin merkkijonoille. Jos koneessa on kytettviss useita eri lajeja merkkijonoja (vaikkapa ASCII-merkit ja kiinalaiset kirjoitusmerkit), voitaisiin ne ottaa kyttn
seuraavasti:
CHARACTER (LEN=80, KIND=lajiparametri) :: rivi
Tss mriteltiin 80 merkin mittainen merkkijono, jonka lajiparametri annetaan mreess KIND=lajiparametri.
Merkkijonovakion laji annetaan ennen merkkijonovakiota:
lajiparametri_Merkkijono
Fortran-standardi mahdollistaa usean merkkijonolajin kytn, mutta ei standardoi tt milln tavalla. Sama ptee totuusarvoihin. Siten Fortranissa ei
ole helppoa tapaa saada selville merkkijonojen tai totuusarvojen lajiparametreja; parhaiten nm selvivt kunkin Fortran-kntjn ksikirjoista.
5. Perustyypit
59
5.5.5 Lajimrittelyn eri muodot

Parametrisoidun tyyppimrittelyn voi antaa numeeristen tyyppien yhteydess mys lyhyemmss muodossa:
INTEGER, PARAMETER :: isoluku = SELECTED_INT_KIND(9)
INTEGER, PARAMETER :: tarkka = SELECTED_REAL_KIND(10,100)
INTEGER (isoluku) :: m, n
REAL (tarkka) :: x, y
COMPLEX (tarkka) :: z
Suosittelemme kuitenkin mrittelyn KIND=laji kyttmist:

INTEGER (KIND=isoluku) :: z
5.5.6 Esimerkki parametrisoiduista tyypeist

Seuraavassa kytmme hyvksi parametrisoituja tyyppimrittelyj piin arvon laskemisessa:
PROGRAM pii
IMPLICIT NONE
INTEGER, PARAMETER :: &
pienitarkkuus = SELECTED_REAL_KIND(6, 30), &
suuritarkkuus = SELECTED_REAL_KIND(12)
REAL (KIND=suuritarkkuus) :: pi1
REAL (KIND=pienitarkkuus) :: pi2
COMPLEX (KIND=suuritarkkuus) :: pi3
pi1 = 4*ATAN(1.0_suuritarkkuus)
pi2 = 4*ATAN(1.0_pienitarkkuus)
pi3 = 6*ASIN(0.5_suuritarkkuus)
WRITE (*,*) pii: , pi1, pi2
WRITE (*,*) pii: , pi3
END PROGRAM pii
Lajiparametria suuritarkkuus laskettaessa jtettiin eksponentin vaihteluvli antamatta, koska ainoastaan merkitsevien numeroiden lukumrll
(12) on esimerkiss merkityst. Kntj valitsee tllin sopivan vaihteluvlin eksponentille.
Ohjelma tulostaa esimerkiksi seuraavan:
pii:
pii:
3.141592653589793
3.141593
(3.141592653589793,0.0000000000000000E+00)
Tss kytetyll laitteistolla vastaavat ohjelmassa kytetyt reaalilukujen lajiparametrit suuritarkkuus ja pienitarkkuus eri tarkkuuden lajeja.
Toisella laitteistolla voisi laji suuritarkkuus olla pienin esitettviss oleva
reaalilukujen tarkkuus, jolloin suuritarkkuus ja pienitarkkuus esittisivt samaa lajia. Tllaisella koneella voisi olla kytettviss mys vaikkapa
28 desimaalin tarkkuuteen pystyv reaalilukulaji.
60
Fortran 95/2003
5.5.7 Kaksoistarkkuus
Aikaisemmassa Fortran-standardissa oli kytss kaksoistarkkuuden tyyppi
DOUBLE PRECISION, joka aiheutti suuria siirrettvyysongelmia: toisen koneen REAL-tyyppi saattoi vastata toisen koneen kaksoistarkkuutta. Kaksoistarkkuuden mrittelyt kannattaa korvata parametrisoiduilla tyypinmrittelyill.
Seuraavassa on esimerkki vanhasta Fortran-koodista:
DOUBLE PRECISION X, Y
X = 1.D0
Y = 2.D0*ACOS(X)
Tss merkint 1.D0 tarkoittaa kaksoistarkkuuden vakiota, jota vastaa yksinkertaisen tarkkuuden vakio 1.E0.
Edellinen ohjelmakoodi on parempi esitt vaikkapa seuraavassa muodossa:
INTEGER, PARAMETER :: dp = SELECTED_REAL_KIND(12)
REAL (KIND=dp) :: x, y
x = 1.E0_dp
y = 2.E0_dp*ACOS(x)
Nyt voimme olla varmoja siit, ett kytetty reaalilukulaji pystyy esittmn
lukuja 12 numeron tarkkuudella riippumatta kytetyn koneen ominaisuuksista.
Huomaa, ett Fortran-kntjt eivt pysty esittmn lukuja mielivaltaisella
tarkkuudella. Esimerkiksi reaalilukujen eri lajeja on tyypillisesti kaksi tai
kolme.
5.6
Esimerkki: sarjan summa
Olkoon laskettavana arvio sarjan summalle

s=
1
.
2
i
i=1
Tarkka arvo on s = 2 /6 1.6449341. Koska emme voi laskea rellisess

ajassa yhteen retnt mr termej, otamme mukaan summaan vain n
termi:
s =
1
.
2
i
i=1
Seuraava ohjelmakoodi tekee tarvittavat laskut:

PROGRAM summaus
IMPLICIT NONE
REAL :: s = 0.0
5. Perustyypit
61
INTEGER :: i, n
WRITE (*,*) Anna termien lukumr:
READ (*,*) n
WRITE (*,*) Termej: , n
DO i = 1, n
s = s + 1/(REAL(i)**2)
END DO
WRITE (*,*) Summa on:, s
END PROGRAM summaus
Funktiokutsu REAL(i) muuttaa kokonaisluvun i reaaliluvuksi, jotta jakolaskun tulos olisi mys reaaliluku. Seuraavassa on ajoesimerkki:
Anna termien lukumr:
100
Termej: 100
Summa on:
1.6349840
Jos laskemme mukaan lis termej, saamme tulokset:

Termej: 1000
Summa on:
1.6439348
Termej: 10000
Summa on:
1.6447253
Termej: 1000000
Summa on:
1.6447253
Miljoonalla termill lasketussa tuloksessa on vain 4 desimaalia oikein, samoin kuin 10000 desimaalin tapauksessa. Ohjelmakoodimme nyttisi siis
tuottavan eptarkkoja tuloksia.
Tulosten huonous johtuu siit, ett summauksessa hvi liikaa informaatiota pyristysvirheiden takia. Tm puolestaan johtuu kytetyn laskentamenetelmn ominaisuuksista.
DO-silmukassa lasketaan lauseessa
s = s + 1/(REAL(i)**2)
yhteen luku s ja luku 1/(REAL(i)**2). Jos muuttuja i on luokkaa 1000, on

jlkimmisen luvun suuruusluokka 1/10002 106 . Luvun s arvo on puolestaan noin 1.6. Seuraavassa havainnollistetaan tt yhteenlaskua (symboli
d esitt nollasta poikkeavia desimaaleja):
1.60000
+0.00000d
1.60000d 1.60000
Koska yhteenlaskettavien suuruusero on iso verrattuna merkitsevien numeroiden mrn, niin myhemmill iteraatiokierroksilla laskettavat termit
eivt en vaikuta muuttujan s arvoon!
Lasketaanpa termit knteisess jrjestyksess! Tllin alussa summataan
yhteen pienet termit ja vasta lopussa listn suurimmat termit. Siis seuraavasti:
62
Fortran 95/2003
DO i = n, 1, -1
s = s + 1/(REAL(i)**2)
END DO
Lause
DO i = n, 1, -1
tarkoittaa, ett silmukkamuuttujan i askel on 1. Silmukkamuuttuja i ky

siis lpi arvot n, n-1, . . . , 1. Tmn ohjelman tulostus on:
Termej: 1000
Summa on:
1.6439345
Termej: 10000
Summa on:
1.6448340
Termej: 1000000
Summa on:
1.6449330
Nyt viimeisess tuloksessa on jo 6 oikeaa desimaalia, mik johtuu siit, ett

laskimme saman suuruusluokan termej yhteen.
Algoritmin muuttamisen lisksi voimme muuttaa reaalilukumuuttujan s lajia tarkemmaksi:
PROGRAM summaus
IMPLICIT NONE
INTEGER, PARAMETER :: tarkkuus = SELECTED_REAL_KIND(12)
REAL (KIND=tarkkuus) :: s = 0.0
INTEGER :: i, n
WRITE (*,*) Anna termien lukumr:
READ (*,*) n
WRITE (*,*) Termej: , n
DO i = n, 1, -1
s = s + 1/(REAL(i, KIND=tarkkuus)**2)
END DO
WRITE (*,*) Summa on:, s
END PROGRAM summaus
Tss mriteltiin reaalilukumuuttujan s vhimmistarkkuudeksi 12 desimaalia. Standardifunktio REAL muuttaa kokonaisluvun reaaliluvuksi. Huomaa, ett KIND-mre on syyt antaa mys funktiokutsun REAL argumenttina, koska lauseke REAL(i) tuottaa oletustarkkuuden reaaliluvun.
Ohjelma tulostaa seuraavaa:
Termej: 1000000
Summa on:
1.6449330668487263
Jos kytetn alkuperist DO-silmukan jrjestyst (DO i = 1, n), saadaan

tulokseksi
Summa on:
1.6449330668487701
Eri jrjestyksess lasketut arvot poikkeavat nyt 15. desimaalissa. Jos laskujrjestyksen on parempi vaihtoehto eli DO i = n, 1, -1, saadaan viel
termej lismll seuraava tulos:
5. Perustyypit
63
Termej: 10000000
Summa on:
1.6449339668482315
Siten sarja suppenee hyvin hitaasti kohti tarkkaa arvoa.

Laskutarkkuuden kasvattamisen sijasta (tai lisksi) on parempi muuttaa laskentamenetelm siten, ettei reaalilukujen rellinen tarkkuus johda huonoihin tuloksiin. Edellisess laskentatehtvss olisimme voineet kytt
summan arvioimiseen kaavaa
s
1
1
+ .
2
i
n
i=1
Tmn arvion virhe on pienempi kuin 1/n2 . Esimerkiksi arvolla n = 1000

saamme tulokseksi s 1.6449345, joka on oikea kuuden desimaalin tarkkuudella.
5.7 Yhteenveto
Fortranissa on viisi perustyyppi: INTEGER, REAL, COMPLEX, LOGICAL ja
CHARACTER.
Mreell PARAMETER luodaan nimettyj vakioita, joiden arvoa ei voi
muuttaa ohjelman ajon aikana.
Perustyyppien lajimre kertoo, millaisen version tyypist haluamme
kyttn.
Kytetty laskentamenetelm sek laskutarkkuus voivat vaikuttaa ratkaisevasti tuloksiin.
Harjoitustehtvi
1. Ovatko seuraavat mrittelyt laillista Fortrania:
DOUBLE :: x
CHARACTER (LEN=*), PARAMETER :: "Nimi"
REAL :: pi = 22/7
REAL :: x = 2., y = -3
REAL :: pii = 22.0/7.0
REAL x = 1.0
Jos mrittelyiss on virheit, korjaa ne.

2. Mrittele nimetty vakio k, jonka arvo on 0.75.
3. Mrittele reaalilukulaji (KIND), joka mahdollistaa laskemisen 10 desimaalin tarkkuudella. Mrittele tll tarkkuudella muuttujia ja vakioita.
4. Mit seuraava ohjelma tulostaa?
64
Fortran 95/2003
PROGRAM tulostus
IMPLICIT NONE
INTEGER, PARAMETER :: reaali = SELECTED_REAL_KIND(10)
REAL(KIND=reaali) :: x
x = 314/1000_reaali
WRITE (*,*) X
END PROGRAM tulostus
Korjaa ohjelmassa oleva virhe.

5. Tutki, millaisia kokonais- ja reaalilukuja kyttmsi Fortran-kntj
osaa ksitell. Ohje: tutki aliohjelmakutsujen
SELECTED_REAL_KIND
SELECTED_INT_KIND
palauttamia arvoja seuraavaan tapaan:

PROGRAM lajitesti
IMPLICIT NONE
INTEGER :: i, laji
DO i = 1, 24
laji = SELECTED_INT_KIND(i)
WRITE (*,*) i = , i, laji = , laji
END DO
END PROGRAM lajitesti
Huomaa, ett lajiparametrin arvot riippuvat kytetyst Fortran-kntjst!

6. Tulosta lausekkeen
1
1
ln(1 + 2) +
(2 + 2) 0.5214 . . .
3
15
arvo vhintn 6 desimaalin tarkkuudella. Kyt funktiokutsuja LOG ja
SQRT. Tulosta lausekkeen arvo lisksi suurimmalla kntjn tuntemalla
reaalilukujen tarkkuudella. Kyt hyvksesi edellisen tehtvn tuloksia.
7. Kappaleessa 3.11 sivulla 32 esiteltiin ohjelma, joka tulostaa arvoja lausekkeelle (1 + 1/x)**x.
Muuta ohjelmaa siten, ett se lukee arvon reaalimuuttujalle x ja tulostaa
lausekkeen (1 + 1/x)**x arvon. Kun muuttujan x arvo kasvaa, lausekkeen arvon pitisi lhesty arvoa e 2.71828. Kokeile ohjelmasi toimintaa syttarvoilla 103 , 106 , 1012 ja 1018 (siis 1E3, 1E6 jne.). Miten
ky?
Liukulukujen kone-epsilon on pienin positiivinen liukuluku, jolle ptee
epyhtl 1.0 + > 1.0. Reaalilukumuuttujan x lajia vastaavan koneepsilonin saa selville seuraavasti:
REAL :: x
REAL, PARAMETER :: eps = EPSILON(x)
Muuta ohjelmaasi siten, ett lasket lausekkeen (1 + 1/x)**x arvon

vain siin tapauksessa, ett ehto
1/x > 100*eps
on voimassa. Muussa tapauksessa ilmoitat, ett annettu syttarvo on

liian suuri.
5. Perustyypit
65
8. Kappaleen 3.16 (sivu 38) simulointiesimerkiss laskettiin yhteen pisteiden etisyyksi lauseessa
s = s + SQRT(SUM((a - b)**2))
Koska pisteiden etisyys on keskimrin noin 0.52, on summan s arvo

likimain 0.52*n, miss muuttuja n on yhteenlaskettujen termien lukumr. Jos luku n on vaikkapa miljoona, lasketaan silmukan viimeisess
summauksessa yhteen luvut, joiden suuruusluokat ovat 0.5 106 ja 0.5.
Jos reaalilukumuuttujassa s on tarkkuutta p merkitsev numeroa,
kuinka monta termi voit laskea yhteen ennen tarkkuuden hvimist? Laske arvio pisteiden vlisen etisyyden odotusarvolle kytten miljoonaa pisteparia. Valitse reaalilukumuuttujan s laji siten, ett tarkkuus
on riittv.
9. Liukulukujen yhtsuuruutta ei pitisi vertailla, vaan sen sijaan on syyt
tarkastella likimrist yhtsuuruutta. Seuraavassa on esimerkki tst:
PROGRAM yhtasuuruus
IMPLICIT NONE
REAL :: x, y
REAL, PARAMETER :: toleranssi = 10*EPSILON(x)
WRITE (*,*) anna x ja y:
READ (*,*) x, y
WRITE (*,*) arvot x ja y:, x, y
IF (ABS(x - y) <= toleranssi*ABS(x)) THEN
WRITE (*,*) x ja y likimain yht suuria
END IF
IF (x - y > toleranssi*ABS(x)) THEN
WRITE (*,*) x selvsti suurempi kuin y
END IF
IF (y - x > toleranssi*ABS(x)) THEN
WRITE (*,*) x selvsti pienempi kuin y
END IF
END PROGRAM yhtasuuruus
Miksi muuttujien erotusta verrataan lausekkeeseen

toleranssi*ABS(x)
eik vakioarvoon toleranssi?

10. Laske likiarvo seuraavan vuorottelevan sarjan summalle:
(1)k1
.
k
k=1
Kokeile eri summausjrjestyksi sek lisksi positiivisten ja negatiivisten alkioiden summausta erikseen. Tulos on ln 2 0.69314718 . . . .
11. Ns. maagisessa summauksessa voidaan kytt pienemmn tarkkuuden
muuttujia, mutta tulos on silti varsin tarkka. Seuraavassa on esimerkki
tarvittavasta koodista:
66
Fortran 95/2003

REAL (KIND=tarkkuus) :: summa, korjaus, &
korjattu_termi, uusi_summa
INTEGER :: i, n
...
summa = f(1)
korjaus = 0.0
DO i = 2, n
korjattu_termi = f(i) - korjaus
uusi_summa = summa + korjattu_termi
korjaus = (uusi_summa - summa) - korjattu_termi
summa = uusi_summa
END DO
Tss funktio f(i) laskee sarjan i:nnen alkion arvon. Kokeile summauksen tarkkuutta edellisess tehtvss.
6. Lausekkeet ja sijoituslauseet
67
Lausekkeet ja
sijoituslauseet
Lausekkeet ja sijoituslauseet ovat ohjausrakenteiden ohella tietokoneohjelmassa ne tykalut, joilla laskentatehtv saadaan ohjelmoitua. Tss luvussa esittelemme Fortran-kielen aritmeettiset, loogiset ja merkkijonolausekkeet. Sijoituslauseiden ksittelyn yhteydess puhumme lausekkeiden eri
osien laskentajrjestyksest. Taulukoita sisltvi lausekkeita ja sijoituslauseita ksittelemme luvussa 11 (sivu 164).
6.1 Aritmeettiset lausekkeet

Koska Fortran on alunperin suunniteltu numeeristen algoritmien ohjelmointiin, on kieless hyvt numeeriset tietotyypit ja operaattorit sek paljon matemaattisia standardifunktioita. Fortranin nimihn on perisin sanoista FORmula TRANslator, eli vapaasti knnettyn kaavankntj.
Fortranin aritmeettiset operaattorit ovat yhteenlasku (+), vhennyslasku (-),
kertolasku (*), jakolasku (/) ja potenssiin korotus (**). Lisksi miinusmerkki lausekkeen edess tarkoittaa etumerkin vaihtoa. Nm operaattorit on
mritelty kokonais-, reaali- ja kompleksiluvuille. Operaattorit on mritelty mys taulukoille, mutta tt ksitelln vasta luvussa 11 (sivu 164).
Operaattoreista etumerkin vaihto lasketaan ensin, sitten potenssiin korotus, kerto- ja jakolaskut ja lopuksi yhteen- ja vhennyslaskut. Lausekkeiden
sidontajrjestyst voi muuttaa sulkuja kyttmll.
Esimerkiksi lauseke
a**2+b/d-3*-5
tulkitaan kuten lauseke

((a ** 2) + (b / d)) - (3 * (-5))
Luvussa -5 esiintyv miinusmerkki kuuluu lukuesitykseen eik siis ole etumerkin vaihto-operaatio. Siten seuraavassa lausekkeessa sulut voi jtt pois
luvun -5 ymprilt mutta ei lausekkeen -c ymprilt:
a**(-5) + a**(-c)
68
Fortran 95/2003
Huomaa, ett aritmeettisissa lausekkeissa operaattorit potenssiin korotusta

lukuunottamatta tulkitaan vasemmalta oikealle. Tllin lauseke
a - b - c + d - e

(((a - b) - c) + d) - e
Vastaavasti jakolaskuja sisltv lauseke

a / b / c * d
tulkitaan seuraavasti:
((a / b) / c) * d
Kntjll on oikeus jrjestll lausekkeita uudestaan tehokkuuden lismiseksi. Tten yll esitetyt lausekkeet saatettaisiin laskea seuraavassa jrjestyksess:
(a + d) - (b + c + e)
(a * d) / (b * c)
Perkkiset potenssiinkorotusoperaattorit tulkitaan oikealta vasemmalle. Tten esimerkiksi

2 ** 3 ** 5

2 ** (3 ** 5)
Kyt aritmeettisissa lausekkeissa vlilyntej ja ylimrisi sulkumerkkej selkeyden lismiseksi. Esimerkiksi lauseke
a ** (b ** (-2)) + d / (e * f * g)
on paljon selkempi ja intuitiivisempi kuin

a**b**-2+d/e/f/g
Ole erityisen varovainen, kun lasket jakolaskua tai potenssiinkorotusta kokonaisluvuille. Kahden kokonaisluvun jakolaskun tulos katkaistaan nollaa
kohti kokonaisluvuksi. Siten esimerkiksi jakolaskun 2/3 tulos on 0 ja jakolaskun -5/3 tulos on -1.
Kun kokonaislukuja korotetaan negatiiviseen potenssiin, tulkitaan tulos ykksen ja vastaavan positiivisen potenssin jakolaskuna. Tm jakolasku tulkitaan kuten mik tahansa kokonaislukujen jakolasku, joten tuloksena on
useimmiten nolla. Lauseke 2**(-3) tulkitaan siis lausekkeeksi 1/(2**3)
eli 1/8, mist tulee tulokseksi nolla. Lauseke
2**(-1/2) tuottaa puolestaan
tulokseksi arvon 20 = 1 eik arvoa 1/ 2.

Jos aritmeettisissa lausekkeissa on erityyppisi operandeja, muutetaan argumentit ennen laskutoimitusta vahvimman ja tarkimman tyypin mukaisiksi. Siten jos esimerkiksi kertolaskussa on kokonaislukuja ja reaalilukuja
sekaisin, muutetaan kokonaisluvut reaaliluvuiksi ennen laskutoimitusta. Samoin jos lausekkeessa on reaali- ja kompleksilukuja, muutetaan kussakin
laskutoimituksessa reaaliluvut ensin kompleksiluvuiksi.
69
Eri tarkkuuden argumentit (KIND-parametri) muutetaan tarkimman argumentin mukaiseksi. Seuraavassa esimerkiss mrittelemme reaalilukujen
lajiparametrit t1 ja t2, joilla luvun esitystarkkuus on vhintn 6 ja 12 numeroa. Lisksi mrittelemme lajeja t1 ja t2 vastaavat muuttujat a ja b:
INTEGER, PARAMETER
INTEGER, PARAMETER
REAL(KIND=t1) :: a
REAL(KIND=t2) :: b
WRITE (*,*) a + b
:: t1 = SELECTED_REAL_KIND(6)
:: t2 = SELECTED_REAL_KIND(12)
= 3.5
= 4.2
Kun luvut a ja b lasketaan yhteen, muutetaan muuttujan a arvo tarkkuuteen

t2 ja tulos on samaa tarkkuutta.
6.2 Numeeriset standardifunktiot

Fortranissa on suuri joukko numeerisia standardifunktioita, joita on esitelty
luvussa 13 (sivu 215). Nit ovat muun muassa
katkaisu- ja pyristysfunktiot
itseisarvo, kompleksikonjugointi, luvun reaali- ja imaginriosa
lukujen tyyppimuunnokset
minimi, maksimi, modulo
logaritmi- ja eksponenttifunktio, nelijuuri
trigonometriset ja hyperboliset funktiot
funktiot, jotka kertovat liukulukuesityksen parametrit
binrilukujen bittioperaatiot
satunnaislukugeneraattori
kellonaika.
Fortran 95 -standardissa parannettiin numeerisia standarifunktioita verrattuna Fortran 90:een. Erityisesti on poistettu ristiriidat IEEE-liukulukuaritmetiikan suhteen: standardi tuntee nyt mm. positiivisen ja negatiivisen nollan
(+0, 0) jne. Funktio SIGN tuottaa negatiivisen nollan, kun ensimminen
argumentti on nolla ja toinen negatiivinen: SIGN(0.0,-1.0).
Seuraavat esimerkit havainnollistavat aritmeettisten lausekkeiden ja numeeristen funktioiden kytt.
6.2.1 Koordinaatiston muunnokset

Ensiksi teemme aliohjelmat, joilla voidaan muuttaa pallokoordinaatit karteesisiksi koordinaateiksi ja pinvastoin. Pallokoordinaatit (r , , ) muutetaan
70
Fortran 95/2003
karteesisiksi koordinaateiksi (x, y, z) seuraavien kaavojen mukaisesti:

x = r sin cos ,
y = r sin sin ,
z = r cos .
Karteesiset koordinaatit muunnetaan pallokoordinaateiksi seuraavasti:

r = x 2 + y 2 + z2 ,

x2 + y 2
= arctan
,
z
y
= arctan .
x
Seuraavassa moduulissa kytetn nit kaavoja muunnoksiin:
MODULE pallokoordinaatit
IMPLICIT NONE
INTEGER, PARAMETER :: prec = SELECTED_REAL_KIND(12, 50)
CONTAINS
SUBROUTINE pallo_xyz(r, theta, phi, x, y, z)
! Tm aliohjelma muuttaa pallokoordinaatit
! r, theta, phi karteesisiksi koordinaateiksi x, y, z
IMPLICIT NONE
REAL(prec), INTENT(IN) :: r, theta, phi
REAL(prec), INTENT(OUT) :: x, y, z
x
y
z
END
= r * SIN(theta) * COS(phi)
= r * SIN(theta) * SIN(phi)
= r * COS(theta)
SUBROUTINE pallo_xyz
SUBROUTINE xyz_pallo(x, y, z, r, theta, phi)

! Tm aliohjelma muuttaa karteesiset koordinaatit
! x, y, z pallokoordinaateiksi r, theta, phi
IMPLICIT NONE
REAL(prec), INTENT(IN) :: x, y, z
REAL(prec), INTENT(OUT) :: r, theta, phi
r = SQRT(x**2 + y**2 + z**2)
theta = ATAN2(SQRT(x**2+y**2),z)
IF (SQRT(x**2+y**2) < 10*EPSILON(x)) THEN
phi = 0
ELSE
phi = ATAN2(y,x)
END IF
END SUBROUTINE xyz_pallo
END MODULE pallokoordinaatit
Kytimme esimerkiss standardifunktiota ATAN2(y,x). Tm funktio palauttaa kompleksiluvun x + i y argumentin eli luvun arctan(y/x). Otimme
lukujen x ja y etumerkit huomioon siten, ett kulma tulee samaan xy-tason
neljnnekseen kuin alkuperinen kompleksiluku.
71
6.2.2 Pyristys- ja katkaisuoperaatiot

Seuraavassa esimerkiss havainnollistamme pyristys- ja katkaisuoperaatioiden toimintaa. Funktio FLOOR katkaisee alaspin, CEILING muuntaa lhinn suuremmaksi kokonaisluvuksi, INT katkaisee kohti nollaa ja NINT
pyrist lhimpn kokonaislukuun:
PROGRAM pyorista
IMPLICIT NONE
REAL, DIMENSION(6) :: numerot = &
(/ 1.4, 1.5, 1.6, -1.4, -1.5, -1.6 /)
INTEGER :: i
WRITE (*,(A))
F
C
I
N
DO i = 1, 6
WRITE (*,(F6.2, 4i4)) numerot(i), &
FLOOR(numerot(i)), CEILING(numerot(i)), &
INT(numerot(i)), NINT(numerot(i))
END DO
END PROGRAM pyorista
Ohjelman tulostus nytt tlt:

1.40
1.50
1.60
-1.40
-1.50
-1.60
F
1
1
1
-2
-2
-2
C
2
2
2
-1
-1
-1
I
1
1
1
-1
-1
-1
N
1
2
2
-1
-2
-2
6.2.3 Laskeminen kompleksiargumenteilla

Useat Fortranin standardifunktiot osaavat laskea kompleksiargumenteilla.
Tllaisia funktioita ovat muun muassa nelijuuri, eksponentti- ja logaritmifunktiot sek sini ja kosini.
Seuraavassa esimerkiss havainnollistamme kompleksiargumenttien kytt. Mrittelemme kompleksiluvut suluissa kirjoitettavina lukupareina. Tulostus tulee samassa muodossa.
PROGRAM kompleksi
IMPLICIT NONE
REAL, PARAMETER :: pii = 3.1415926535
COMPLEX, PARAMETER :: i = (0.0, 1.0)
WRITE (*,*) SQRT((-1.0, 0.0))
WRITE (*,*) EXP(i*pii)
WRITE (*,*) LOG((-1.0, 0.0))
WRITE (*,*) SIN(i)
END PROGRAM kompleksi

(0.0000000E+00,1.000000)
(-1.000000,-8.7422777E-08)
72
Fortran 95/2003
(0.0000000E+00,3.141593)
(0.0000000E+00,1.175201)
Laskemme
ohjelmassa numeerisesti likiarvot matemaattisille lausekkeille
1 = i, ei = 1, log(1) = i ja sin i = i sinh 1.
6.2.4 Toisen asteen yhtln ratkaiseminen

Seuraavassa toteutamme toisen asteen yhtln
ax 2 + bx + c = 0
(6.1)
ratkaisukaavan
x=
b2 4ac
2a
(6.2)
kompleksiargumenteilla.
PROGRAM juuret
IMPLICIT NONE
COMPLEX :: a, b, c, juuri1, juuri2
WRITE (*,*) Anna toisen asteen yhtln kompleksiset &
&kertoimet
WRITE (*, (A), ADVANCE=NO) a:
READ (*,*) a
WRITE (*, (A), ADVANCE=NO) b:
READ (*,*) b
WRITE (*, (A), ADVANCE=NO) c:
READ (*,*) c
CALL toinenaste(a, b, c, juuri1, juuri2)
WRITE (*,*) Juuret ovat , juuri1, juuri2
CONTAINS
SUBROUTINE toinenaste(a, b, c, j1, j2)
IMPLICIT NONE
COMPLEX, INTENT(IN) :: a, b, c
COMPLEX, INTENT(OUT) :: j1, j2
COMPLEX :: diskr
diskr = SQRT(b**2-4*a*c)
j1 = (-b+diskr)/(2*a)
j2 = (-b-diskr)/(2*a)
END SUBROUTINE toinenaste
END PROGRAM juuret
Kyttj sytt ohjelmalle yhtln kertoimet kompleksilukuina, joissa reaali- ja imaginriosa kirjoitetaan sulkuihin. Sytss voi kytt joko kokonaisluku- tai reaalilukuesityst.
Anna toisen asteen yhtln kompleksiset kertoimet
a: (2, 3)
b: (-3, -1)
c: (1.0, 1.0)
Juuret ovat (0.4392123,-0.8573956) (0.2530954,0.3189341)
73
Esimerkiss ratkaisimme yhtln (2 + 3i)x 2 + (3 i)x + (1 + i) = 0.

Huomaa, ett aliohjelmassa toinenaste kytetty ratkaisukaava (6.2) on numeerisesti epstabiili, jos b ja diskr ovat lhell toisiaan. Lisksi termit
b**2 ja 4*a*c voivat aiheuttaa ylivuodon, jos luku b tai luvut a ja c ovat
hyvin suuria. Ylivuodon voi vltt skaalaamalla yhtln (6.1) suurimmalla
kertoimella. Termin b ja nelijuurilausekkeen erotuksen voi laskea stabiilisti vaihtoehtoisella ratkaisukaavalla
x=
2c
.
b2 4ac
Tm on harjoitustehtvn.
6.3 Merkkijonolausekkeet
Tarvitsemme merkkijonolausekkeita sytn ja tulostuksen yhteydess sek
tekstimuotoista tietoa ksitteleviss sovelluksissa. Fortranissa on lukuisia
merkkijonoja ksittelevi standardifunktioita. Fortran 90 -standardin liitnnisstandardina (ISO/IEC 1539-2:1994) on olemassa tuki mys vaihtelevan
pituisille merkkijonoille.
Fortranin merkkijonomuuttujat mritelln lauseella CHARACTER. Ilman argumentteja lauseella voi mritell yhden merkin pituisia muuttujia, muuten
pituus on annettava LEN-parametrin avulla:
CHARACTER :: merkki
CHARACTER(LEN=10) :: merkkijono
Voimme poimia merkkijonosta alimerkkijonon tai yksittisi merkkej seuraavan ohjelman mukaisesti:
PROGRAM koe
IMPLICIT NONE
merkkijono = Fortran
WRITE (*,*) merkkijono(2:4)
END PROGRAM koe
Jos sijoitettava merkkijono on pidempi kuin merkkijonomuuttuja, katkaistaan merkkej merkkijonon lopusta. Jos sijoitettava merkkijono on lyhyempi
kuin muuttuja, listn muuttujan loppuun vlilyntej.
Edellisen ohjelman tulostus nytt tlt:
ort
a
Merkkijonojen liitosoperaattori // muodostaa annetuista merkkijonoista uuden merkkijonon, joka on saatu liittmll nm kaksi perkkin. Tarkastelemme seuraavaa esimerkkiohjelmaa:
74
Fortran 95/2003
PROGRAM koe
IMPLICIT NONE
CHARACTER(LEN=30) :: etunimi = James
CHARACTER(LEN=30) :: sukunimi = Bond
CHARACTER(LEN=30) :: kone = @csc.fi
WRITE (*,*) Osoite: // TRIM(etunimi) // . &
// TRIM(sukunimi) // kone
END PROGRAM koe
Standardifunktio TRIM poistaa merkkijonon lopussa olevat vlilynnit. Ohjelma tulostaa merkkijonolausekkeen, joka saadaan liittmll nelj merkkijonolauseketta perkkin:
Osoite:James.Bond@csc.fi
6.4
Merkkitiedon ksittelyfunktioita
Fortran 95 ksitt mm. seuraavat standardifunktiot merkkijonojen ksittelyyn:

ADJUSTL(string) poistaa merkkijonon alussa olevat vlilynnit ja siirt ne merkkijonon loppuun.
ADJUSTR(string) siirt merkkijonon lopussa olevat vlilynnit merkkijonon alkuun.
INDEX(string,substring) palauttaa merkkijonon substring alkupaikan
merkkijonossa string tai nollan, jos yhteisi merkkej ei ole.
LEN(string) palauttaa merkkijonon pituuden.
LEN_TRIM(string) palauttaa merkkijonon pituuden ilman lopussa olevia vlilyntej.
TRIM(string) palauttaa alkuperisen merkkijonon ilman lopussa olevia
vlilyntej.
SCAN(string,set) palauttaa ensimmisen paikan, jossa merkkijonon set
merkki esiintyy merkkijonossa string, tai nollan, jos yhteisi merkkej
ei ole.
VERIFY(string,set) palauttaa nollan, jos kaikki annetun merkkijonon
string merkit esiintyvt merkkijonossa set, muuten ensimmisen poikkeavan merkin paikan.
Voit list funktioihin INDEX, SCAN ja VERIFY ylimrisen loogisen argumentin mask. Jos tmn argumentin arvo on .TRUE., merkkej etsitn
lopusta alkuun pin.
Voit kytt SCAN-funktiota esimerkiksi etsiesssi lukuja sytevirrasta. Seuraavassa lausekkeessa muuttujaan alku tulee merkkijonon rivi ensimmisen numeron paikka tai luku 0, jos merkkijonossa ei ole numeroita:
75
alku = SCAN(rivi, 0123456789)
Voit kytt VERIFY-funktiota tarkastamaan, ett merkkijonossa esiintyy

vain sallittuja merkkej. Seuraavassa lausekkeessa muuttuja tulos saa arvon nolla, jos merkkijono rivi voidaan tulkita oktaaliluvuksi, ja muuten
ensimmisen poikkeavan merkin paikan:
tulos = VERIFY(rivi, 01234567 )
Seuraava esimerkkiohjelma lukee nppimistlt etuja sukunimi ja tulostaa niiden perusteella muodostetun osoitteen. Ohjelmassa poistetaan merkkijonon lopussa olevat vlilynnit kahdella eri tavalla.
PROGRAM osoite
IMPLICIT NONE
CHARACTER(LEN=30) :: etunimi
CHARACTER(LEN=30) :: sukunimi
CHARACTER(LEN=30) :: kone = @csc.fi
WRITE (*, (A), ADVANCE=NO) Etunimi:
READ (*,*) etunimi
WRITE (*, (A), ADVANCE=NO) Sukunimi:
READ (*,*) sukunimi
WRITE (*,(5A)) Osoite: // TRIM(etunimi) // "." &
// sukunimi(1:LEN_TRIM(sukunimi)) // kone
END PROGRAM osoite
WRITE-lauseissa kytetty mre ADVANCE=NO est tulostuksen siirtymisen seuraavalle riville, kuten muuten tapahtuisi. Ohjelman kytt nytt
tlt:
Etunimi:Jaska
Sukunimi:Jokunen
Osoite:Jaska.Jokunen@csc.fi
6.5 Merkkitieto ja taulukot

Fortranissa on mahdollista ksitell mys merkkitaulukoita ja merkkijonotaulukoita. Kun tavallinen merkkijono sijoitetaan taulukkoon, sijoitetaan
Fortranin taulukkosyntaksin mukaisesti sama merkkijono taulukon kaikkiin
alkioihin.
Seuraavassa ohjelmassa muuttuja merkkijono on tavallinen merkkijono ja
muuttuja merkkitaulukko on taulukko, jossa on kymmenen yhden merkin
mittaista alkiota. Muuttuja merkkijonotaulukko puolestaan sislt viisi
alkiota, joista kukin on kymmenen merkin mittainen merkkijono.
PROGRAM taulut
IMPLICIT NONE
CHARACTER, DIMENSION(10) :: merkkitaulukko
CHARACTER(LEN=10), DIMENSION(5) :: merkkijonotaulukko
76
Fortran 95/2003
merkkijono = Fortran
merkkitaulukko = +
merkkijonotaulukko = Fortran
WRITE (*,*) merkkijono
WRITE (*,*) merkkitaulukko
WRITE (*,*) merkkijonotaulukko
WRITE (*,*) merkkitaulukko(2:4)
WRITE (*,*) merkkijonotaulukko(1:2)(4:6)
END PROGRAM taulut
Viittaamme merkkijonoon ja merkkitaulukkoon tss esimerkiss samalla

tavalla eli kyttmll sulkuja ( . . . ). Merkkijonotaulukon viittauksessa
merkkijonotaulukko(1:2)(4:6)
ensimminen sulkulauseke valitsee taulukon alkiot 1 ja 2 ja toinen sulkulauseke nist alkioista merkit 4:st 6:een.
Fortran
++++++++++
Fortran
Fortran
ort
+++
tra
tra
Fortran
Fortran
Fortran
Huomaa, ett tulostus voi vaihdella koneesta toiseen, koska eri kntjt tulkitsevat muotoilukoodin * eli listan ohjaaman tulostuksen eri tavoin. Tst
kerrotaan lis kappaleessa 12.3 (sivu 194).
6.6
Loogiset lausekkeet
Loogisia lausekkeita kytetn IF-lauseen ja muiden ohjausrakenteiden yhteydess, ja niill siis toteutetaan ohjelman logiikka. Loogisiin lausekkeisiin
kuuluvat lukujen ja merkkijonojen vertailuoperaattoreiden lisksi loogiset
operaattorit.
Fortran-kielen vertailuoperaattorit on lueteltu taulukossa 6.1. Taulukossa
on annettu mys vanhat FORTRAN 77:n mukaiset operaattorit (.EQ. jne.).
Vertailuoperaattoreilla muodostettuja lausekkeita voi yhdistell loogisilla
operaattoreilla. Aritmeettiset operaatiot sitovat operandeja vahvemmin kuin
vertailuoperaattorit, jotka puolestaan ovat vahvempia kuin loogiset operaattorit. Loogisten operaattoreiden sidontajrjestys on taulukon 6.2 mukainen,
eli operaattori .NOT. suoritetaan ennen muita operaattoreita.
Loogisten operaattorien toimintaa on havainnollistettu taulukossa 6.3. Huomaa, ett operaattori .NEQV. on poissulkeva tai-operaattori (exclusive or).
77
Taulukko 6.1: Vertailuoperaattorit.
Vertailuoperaattori
Vanha muoto Selitys
==
/=
<
>
<=
>=
.EQ.
.NE.
.LT.
.GT.
.LE.
.GE.
Yhtsuuruus
Erisuuruus
Pienempi kuin
Suurempi kuin
Pienempi tai yhtsuuri kuin
Suurempi tai yhtsuuri kuin
Taulukko 6.2: Loogiset operaattorit.
Operaattori
Selitys
.NOT.
.AND.
.OR.
.EQV.
.NEQV.
Looginen negaatio
Looginen ja
Looginen tai
Looginen ekvivalenssi
Looginen epekvivalenssi
6.7 Esimerkkej loogisista lausekkeista

Havainnollistamme loogisten lausekkeiden kytt muutamilla esimerkeill.
Seuraava IF-rakenne keskeytt ohjelman suorituksen, jos luku x ei ole vlill [1, 5]:
IF (x < 1 .OR. x > 5) THEN
WRITE (*,*) Virhe: x ei ole vlill [1, 5]
STOP
END IF
Seuraava IF-rakenne tutkii, onko pistepari (x, y) yksikknelin sisll:

IF (x >= 0 .AND. x <= 1 .AND. y >= 0 .AND. y <= 1) THEN
WRITE (*,*) Piste (x,y) on yksikkneliss
END IF
Seuraava ehtolauseke testaa, pteek epyhtl ||x| 2| < 1:

IF (x > -3 .AND. x < -1 .OR. x > 1 .AND. x < 3) THEN
WRITE (*,*) x toteuttaa epyhtln | |x| - 2 | < 1
END IF
Ehto olisi tietysti voitu kirjoittaa mys muotoon

IF (ABS(ABS(x)- 2) < 1)
78
Fortran 95/2003
Taulukko 6.3: Loogisten operaattorien toiminta. Merkint F tarkoittaa arvoa eptosi

ja T arvoa tosi.
a
F
F
T
T
b
F
T
F
T
a .AND. b
F
F
F
T
a .OR. b
F
T
T
T
a .EQV. b
T
F
F
T
a .NEQV. b
F
T
T
F
Ohjelmassa ei pid verrata reaalilukujen yhtsuuruutta operaattorilla ==

vaan tutkia, ovatko reaaliluvut riittvn lhell toisiaan. l siis kirjoita ohjelmaasi lausetta
IF (x == a) THEN
vaan kyt vaikkapa lausetta

IF (ABS(x - a) < 10*EPSILON(a)*ABS(a)) THEN
Funktio EPSILON palauttaa muuttujan a tyyppi vastaavan kone-epsilonin

arvon: on pienin positiivinen luku, jolle ptee 1.0 + > 1.0.
Voit sijoittaa loogisten lausekkeiden arvoja mys muuttujiin. Seuraavassa
ohjelmassa tutkimme, kuuluuko lukupari (x, y) nelin [0, 2] [0, 2], nelin [1, 3] [1, 3] vai kumpaankin.
PROGRAM numerot
IMPLICIT NONE
LOGICAL :: nelio1, nelio2
REAL :: x, y
WRITE (*,*) Anna lukupari x ja y
READ (*,*) x, y
nelio1 = (x >= 0 .AND. x
nelio2 = (x >= 1 .AND. x
IF (nelio1 .AND. nelio2)
WRITE (*,*) Piste on
ELSE IF (nelio1) THEN
ELSE IF (nelio2) THEN
ELSE
END IF
END PROGRAM numerot
6.8
<=2 .AND. y >= 0 .AND. y <= 2)

<=3 .AND. y >= 1 .AND. y <= 3)
THEN
kummassakin neliss
neliss 1
neliss 2
neliiden ulkopuolella
Merkkijonojen vertailu
Vertailuoperaattoreilla <, >, == jne. voi vertailla mys merkkijonoja, jolloin

vertailu tehdn merkki kerrallaan. Aluksi vertailtavista merkkijonoista teh-
79
dn yht pitki lismll lyhyemmn merkkijonon loppuun vlilyntej.

Siten esimerkiksi merkkijonot kukkuu ja kukkuu ovat Fortranin vertailuoperaattoreiden mielest samoja.
Yksittisten merkkien jrjestys on koneriippuvainen etenkin skandinaavisten kirjaimien ja muiden erikoismerkkien osalta. Merkkien jrjestys riippuu
merkkikoodista, joka voi olla eri koneissa erilainen. Jotta ohjelmat voitaisiin helpommin kirjoittaa siirrettviksi, on Fortranissa mahdollista vertailla
merkkej ja merkkijonoja joko konekohtaisen merkkikoodin tai standardoidun ASCII-koodin mukaan (katso liitett D sivulla 324). Kyttmll jlkimmist vaihtoehtoa saamme ohjelmasta siirrettvmmn joskin ehk hitaamman.
Jokaista merkki vastaa kokonaislukukoodi, jota kytetn selvitettess
merkkien jrjestyst. Yksittisen merkin jrjestysnumeron koneen sisisess merkistss saa selville standardifunktiolla ICHAR ja ASCII-merkistss
funktiolla IACHAR. Funktiot CHAR ja ACHAR puolestaan palauttavat jrjestysnumeroa vastaavan merkin.
Fortran edellytt, ett koneen sisisess merkistss numerot 09 sek kirjaimet AZ ovat luonnollisessa jrjestyksess, eli A tulee ennen B:t, Y ennen
Z:aa ja 0 tulee ennen ykkst. Lisksi edellytetn, ett vlilynti tulee ennen numeroita ja kirjaimia ja ett kaikki numerot tulevat joko ennen kaikkia
kirjaimia tai kaikkien kirjainten jlkeen. Standardi ei ota kantaa pienten ja
isojen kirjainten keskeniseen sijoitteluun eik erikoismerkkien ja skandinaavisten merkkien jrjestykseen.
ASCII-merkist mrittelee merkkikoodit 0127 ja siihen sisltyy numerot,
isot ja pienet kirjaimet sek tiettyj erikois- ja ohjausmerkkej. Funktiot
IACHAR ja ACHAR voivat tuntea mys 127: suurempia merkkikoodeja, mutta niden sislt on koneriippuvainen. Useissa tietokoneissa koneen sisinen
merkist on ASCII tai jokin sen laajennus.
Kun vertailet merkkijonoja operaattoreilla <, >, == jne., kytetn vertailujrjestyksen koneen sisist merkist. ASCII-merkist varten on olemassa
standardifunktiot LGE, LGT, LLE ja LLT. Nm funktiot vertailevat merkkijonojen ASCII-jrjestyst operaatioilla , >, ja <.
Seuraavassa esimerkiss vertailemme kahta merkkijonoa koneen sisist ja
ASCII-merkist kytten:
CHARACTER(LEN=10) :: mjono1, mjono2
...
IF (mjono1 < mjono2) THEN
WRITE (*,*) Sisinen merkist: , mjono1, &
on ennen jonoa , mjono2
END IF
IF (LLT(mjono1, mjono2)) THEN
WRITE (*,*) ASCII-merkist: , mjono1, &
on ennen jonoa , mjono2
END IF
80
Fortran 95/2003
6.9
Esimerkki: merkkijonojen lajittelu
Seuraava ohjelma lukee ptteelt rivien lukumrn ja lajiteltavat rivit. Rivit lajitellaan edell kuvattuun, koneen sisisen merkistn mukaiseen jrjestykseen kytten valintalajittelua (selection sort). Muuttuja sivu on taulukko, jonka kukin alkio on 80 merkki pitk merkkijonomuuttuja. Lauseke
sivu(1:rivit) viittaa taulukon riveihin 1-rivit ja lauseke sivu(j) tarkoittaa koko rivi j.
PROGRAM lajittele
! Ohjelma lukee sisn lajiteltavan tekstin
! sek tulostaa lajitellun tekstin.
IMPLICIT NONE
INTEGER, PARAMETER :: maxrivit = 100
CHARACTER(LEN=80), DIMENSION(maxrivit) :: sivu
CHARACTER(LEN=80) :: apu
INTEGER :: rivit, pienin, i, j
WRITE (*,*) Anna rivien lukumr:
READ (*,*) rivit
IF (rivit > maxrivit) THEN
WRITE (*,*) Liian monta rivi!
STOP
END IF
WRITE (*,*) Syt rivit:
READ (*, (A)) sivu(1:rivit)
DO i = 1, rivit-1
pienin = i
DO j = i+1, rivit
IF (sivu(j) < sivu(pienin)) pienin = j
END DO
apu = sivu(pienin)
sivu(pienin) = sivu(i)
sivu(i) = apu
END DO
WRITE (*,*) Lajiteltu taulukko:
WRITE (*,(A)) sivu(1:rivit)
END PROGRAM lajittele
Ohjelman kytt voisi nytt tlt:

Anna rivien lukumr:
4
Syt rivit:
sidewise
crosswise
clockwise
pairwise
Lajiteltu taulukko:
clockwise
crosswise
pairwise
81
sidewise
Jos haluat kytt edellisess lajitteluohjelmassa ASCII-merkistn perustuvaa vertailua, voit tehd sen seuraavalla IF-lauseella:
IF (LLT(sivu(j), sivu(pienin))) pienin = j
6.10 Sijoituslauseet ja laskentajrjestys

Olemme jo aikaisemmin kyttneet Fortranin sijoituslauseita. Nyt ksittelemme lyhyesti sijoituslauseissa esiintyvi tyyppimuunnoksia sek lausekkeiden osien suoritusjrjestyst.
Sijoituslauseissa voit sijoittaa eri tyyppisi lausekkeita muuttujiin, jos nille tietotyypeille on mritelty tyyppimuunnokset. Voit sijoittaa esimerkiksi
kokonaislukumuuttujiin reaali- tai kompleksimuuttujia, jolloin muuttujan
arvo katkaistaan kokonaisluvuksi nollaa kohti ja imaginriosa pudotetaan
pois. Sijoitettaessa isomman tarkkuuden reaaliluku pienemmn tarkkuuden
reaalilukuun joudutaan alkuperinen reaaliluku pyristmn.
Reaalimuuttujiin voi sijoittaa kokonais- ja kompleksilukulausekkeita. Vastaavasti kompleksimuuttujiin voi sijoittaa reaali- tai kokonaislukulausekkeita. Sijoitettaessa arvoja kokonais-, reaali- ja kompleksimuuttujiin kytetn
automaattisesti standardifunktioita INT, REAL ja CMPLX tarvittaviin muunnoksiin.
Taulukossa 6.4 on havainnollistettu sijoituslauseessa tapahtuvia numeeristen tyyppien muunnoksia. Loogisen lausekkeen arvoa ei voi sijoittaa muuhun
kuin loogiseen muuttujaan. Vastaavasti merkkijonolausekkeen voi sijoittaa
vain merkkijonomuuttujaan, jolloin tehdn tarvittaessa merkkijonon katkaisu tai vlilyntien lisminen merkkijonomuuttujan loppuun.
Taulukko 6.4: Automaattiset tyypinmuunnokset sijoituksessa a = b. Merkint =
tarkoittaa, ettei muunnosta tarvita.
a
REAL
COMPLEX
INTEGER
b: INTEGER
=
katkaisu
reaaliosan otto ja
katkaisu
REAL
esitysmuodon
muunnos
reaaliosan otto
COMPLEX
esitysmuodon
muunnos
esitysmuodon
muunnos
Seuraavassa ohjelmassa sijoitamme lausekkeita erityyppisiin muuttujiin ja

tulostamme muuttujien arvot:
PROGRAM numerot
IMPLICIT NONE
INTEGER :: i
REAL :: r
82
Fortran 95/2003
COMPLEX :: c
i = 7.3
r = (1.618034, 0.618034)
c = 2.7182818
WRITE (*,*) i, r, c
END PROGRAM numerot

7
1.618034
(2.718282,0.0000000E+00)
Merkkijonolausekkeiden sijoituksessa liian pitk merkkijono katkaistaan, ja

liian lyhyt merkkijono tytetn lopusta vlilynneill:
PROGRAM sijoitus
IMPLICIT NONE
CHARACTER(LEN=10) :: merkit = Suutari
WRITE (*,*) merkit
merkit(1:4) = Se
WRITE (*,*) merkit
merkit(4:5) = Jeeves
WRITE (*,*) merkit
END PROGRAM sijoitus

Suutari
Se ari
Se Jeri
Lausekkeen oikea puoli lasketaan aina kokonaan, ennen kuin sijoitusoperaatiota ruvetaan suorittamaan. Erityisen trke tm on merkkijonomuuttujia
ksiteltess ja myhemmin luvussa 11 esiteltvien taulukoiden ksittelyss.
Seuraavassa esimerkiss merkkijonon merkit alimerkkijonot menevt pllekkin, mutta sijoituksessa kytetn muuttujan vanhaa arvoa:
PROGRAM siirto
IMPLICIT NONE
CHARACTER(LEN=10) :: merkit = Raskas
WRITE (*,*) merkit
merkit(3:6) = merkit(4:7)
WRITE (*,*) merkit
END PROGRAM siirto
Ohjelman tulostaa seuraavaa:

Raskas
Rakas
6.11
83
Funktioiden sivuvaikutukset
Kyttjn mrittelemien funktioiden sivuvaikutukset eivt vlttmtt tuota haluttua tulosta. Esimerkiksi voimme kirjoittaa funktion f, joka pit sisisell laskurilla kirjaa kutsukerroistaan. Kun ohjelmassa esiintyy lauseke
f(x) + f(x)
kntj voi optimoida tmn lausekkeeksi 2*f(x), jolloin laskuri toimii eri
tavalla.
Funktio ei saa muuttaa argumenttejaan, jos todellisia argumentteja kytetn muualla samassa lausekkeessa. Esimerkiksi lausekkeessa f(x) + f(x)
kytetty funktio f ei saa muuttaa argumenttia x.
Kntjn ei tarvitse laskea lausekkeen kaikkia osia, jos se pystyy pttelemn lausekkeen arvon muuten. Esimerkiksi ehtolauseessa
IF (x < 0 .AND. f(x) < 0) THEN
kntjn ei tarvitse kutsua f-funktiota, jos x 0, koska loogisen lausekkeen

arvo on tllin vlttmtt eptosi. Toisaalta kntj voi kutsua f-funktiota,
jos se haluaa.
Nollalla jakamista ei voi est seuraavan tyyppisell lausekkeella:
IF (a /= 0 .AND. 1/a < 1) THEN
vaan tm pit testata kahdessa eri ehtolausekkeessa:

IF (a /= 0) THEN
IF (1/a < 1) THEN
...
6.12
Operaattorien sidontajrjestys
Taulukossa 6.5 on lueteltu tss luvussa esitetyt operaattorit ja niiden tyypit.

Operaattorit on esitetty niiden sidontajrjestyksess eli ylempn esitetyt
operaattorit ovat vahvempia kuin alempana annetut. Mukaan on otettu mys
kyttjn mrittelemt operaattorit, joita tarkastellaan luvussa 9 (sivu 126).
6.13
Yhteenveto
Fortranin lausekkeissa voi esiinty vakioita, muuttujia, operaattoreita, standardifunktioiden kutsuja ja omien funktioiden kutsuja. Sijoituslausekkeen
oikea puoli lasketaan kokonaan ennen sijoitusta. Operaattorien sidontajrjestys on esitetty taulukossa 6.5.
Lausekkeiden suoritusjrjestys ei ole ennalta mrtty, vaan kntj voi
84
Fortran 95/2003
jrjest lausekkeita uudelleen ja optimoida pois tarpeettomia osia ja funktiokutsuja.

Taulukko 6.5: Operaattorien sidontajrjestys.
Operaattorin tyyppi
Operaattori
Numeerinen
Numeerinen
Numeerinen
Numeerinen
Merkkijono
Vertailu
Looginen
Looginen
Looginen
Looginen
kyttjn mrittelem yksiargumenttinen

**
* tai /
yksiargumenttinen + tai kaksiargumenttinen + tai //
== /= < <= > >=
.NOT.
.AND.
.OR.
.EQV. tai .NEQV
kyttjn mrittelem kaksiargumenttinen
Harjoitustehtvi
1. Mik on lausekkeen 2* -3-4** 2*3 arvo?
2. Mik on lausekkeen 2/3 * 2 arvo?
3. Paljonko on 1.0/2.0/3.0?
4. Miten seuraava lausekkeet poikkeavat toisistaan:
2 ** -3
2.0 ** -3
5. Ovatko seuraavat lausekkeet laillista Fortrania:

2.0
2.0
2.0
2.0
**
**
**
**
(-3)
-3
(-c)
-c
6. Miten seuraava lausekkeet poikkeavat toisistaan:

7 / (2 + 3)
7 / (2.0 + 3)
7. Laske arvo lausekkeille

4.0 / 3.0 / 2.0
4.0 ** 3.0 ** 2.0
8. Ohjelmakoodissa on mritelty
CHARACTER(LEN=8) :: a = Helsinki
CHARACTER(LEN=8) :: b = juurekas
85
Mink arvon saa lauseke a(1:2) // b(3:7)?

9. Jos 8-merkkisen merkkijonon merkit arvo on Onnela, niin mik on
sen arvo sijoituksen merkit(5:6) = merkit(6:8) jlkeen?
10. Miss jrjestyksess suoritetaan seuraava lauseke:
a .AND. .NOT. b .OR. .NOT. a .AND. b
Laadi lausekkeelle totuustaulukko. Mik looginen operaatio on kyseess?

11. Laadi ohjelma, joka lukee ptteelt heksadesimaalilukuja ja tarkistaa
niiden oikeellisuuden.
12. Laadi ohjelma, joka testaa, sijaitseeko annettu piste nelin [1, 1]
[1, 1] sisll ja yksikkympyrn ulkopuolella.
13. Kappaleessa 6.2.4 (sivu 72) ksitelln toisen asteen yhtln ratkaisemista. Toteuta ohjelma niin, ett ratkaisukaavan numeerinen epstabiilisuus vltetn.
86
Fortran 95/2003
Ohjausrakenteet
Ohjausrakenteiden avulla voimme toistaa laskutoimituksia niin usein kuin

on tarpeen tai suorittaa ne vain halutun ehdon toteutuessa. Fortran-kieli
sislt laajan valikoiman ohjausrakenteita. Seuraavassa kymme lpi eri
mahdollisuudet lyhyiden esimerkkien avulla.
7.1
Mihin tarvitsemme ohjausrakenteita
Kytimme edellisten lukujen esimerkeiss pasiassa perkkin kirjoitettuja

ohjelmakoodin lauseita, jotka suoritetaan annetussa jrjestyksess. Useimmin laskentatehtv ei kuitenkaan voi ratkaista jonona perkkisi lauseita,
vaan tarvitsemme testej ja toistorakenteita.
Tllaisia tehtvi varten on Fortranissa monipuolinen valikoima ohjausrakenteita, joissa yleens mritelln jokin lausejono eli ohjelmalohko suoritettavaksi ohjausrakenteen mrmll tavalla.
Perkkisyys tarkoittaa sit, ett ohjelmakoodiin kirjoitetut lauseet suoritetaan annetussa jrjestyksess. Valinnalla suoritetaan annetuissa ohjelmalohkoissa olevat lauseet vain sopivien ehtojen toteutuessa. Toisto mahdollistaa annetun ohjelmalohkon suorittamisen toistuvasti, esimerkiksi kunnes
toistolauseen lopetusehto toteutuu. Hyppylause siirtyy suorittamaan ohjelmayksikn annettua lausetta.
Ohjausrakenteet voivat olla mys toisiinsa nhden siskkin, jolloin esimerkiksi toistolause voidaan suorittaa vain annetun ehdon toteutuessa.
Proseduurin kutsu siirtyy suorittamaan proseduurissa (aliohjelma tai funktio) mriteltyj lauseita ja palaa lopulta takaisin kutsuvaan ohjelmayksikkn. Proseduureja ksitelln luvussa 8 (sivu 99).
7.2
Ehdollinen suoritus: IF-rakenne
IF-rakenteen avulla voimme antaa ehdon ohjelmalohkon lauseiden suorittamiselle. Taulukossa 7.1 on esitetty IF-rakenteen yleinen muoto.
7. Ohjausrakenteet
87
Taulukko 7.1: IF-rakenteen yleinen muoto.
[tunniste:] IF (ehto) THEN

lohko
[ELSE IF (ehto) THEN [tunniste]
lohko]
[ELSE [tunniste]
lohko]
END IF [tunniste]
Yksinkertaisin esimerkki IF-rakenteesta on seuraava:

IF (ehto) THEN
lohko
END IF
Tss lohko tarkoittaa jonoa suoritettavia lauseita tai ohjausrakenteita.

IF-rakenteen sisll olevaan lohkoon kuuluvat lauseet suoritetaan siin tapauksessa, ett loogisen lausekkeen ehto arvo on tosi. Esittelimme loogisia
lausekkeita kappaleessa 6.6 (sivu 76).
Vaihdamme seuraavassa esimerkiss muuttujien arvot, jos x on suurempi
kuin y:
IF (x > y) THEN
t = y
y = x
x = t
END IF
Jos haluamme tehd jotain muuta IF-rakenteen ehdon ollessa eptosi, voimme kytt ELSE-haaraa:
IF (x /= 0.0) THEN
y = 1.0/x
ELSE
WRITE (*,*) Nollalla jako
y = 0.0
END IF
Voimme sijoittaa IF-rakenteita mys siskkin. Lisksi voimme antaa IFrakenteelle tunnisteen, jolloin erityisesti siskkisten rakenteiden logiikka
voi tulla koodin lukijalle selkemmksi. Mys sisennyst kannattaa kytt, mutta se ei mr ohjelmakoodin logiikkaa. Seuraavassa on esimerkki
siskkisist IF-rakenteista:
ulompi: IF (x /= 0.0) THEN
sisempi: IF (y > 0.0) THEN
t = y/x
ELSE IF (y == 0.0) THEN sisempi
t = 0.0
ELSE sisempi
88
Fortran 95/2003
t = -y/x
END IF sisempi
END IF ulompi
Kytmme tss IF-lauseiden tunnisteita ulompi ja sisempi. Tunnisteiden

avulla voidaan pitkiss ja monimutkaisissa IF-rakenteissa merkit nkyviin,
mihin rakenteeseen esitetty ehto liittyy.
IF-rakenteen lisksi voimme kytt IF-lausetta, jossa suoritettavana on
vain yksi lause:
IF (ehto) lause
IF-lause vie vhemmn rivej kuin IF-rakenne, mutta se soveltuu vain yksinkertaisiin tapauksiin:
IF (x /= 0.0) y = 1/x
7.3
Tapausten ksittely: SELECT CASE -rakenne
SELECT CASE -rakenne on IF-lauseen vaihtoehto silloin, kun testaamme, kuuluuko annettu arvo tiettyyn joukkoon arvoja. Yleens testataan
kokonaisluku- tai merkkijonojoukkoja. Fortranin SELECT CASE -rakenne on
monipuolisempi kuin esimerkiksi Pascalin tai C-kielen vastaavat rakenteet.
Rakenteen yleinen muoto on esitetty taulukossa 7.2.
Taulukko 7.2: SELECT CASE -rakenteen yleinen muoto.
[tunniste:] SELECT CASE (lauseke)

[CASE (arvo[, arvo] . . . ) [tunniste]
lohko]...
[CASE DEFAULT [tunniste]
lohko]
END SELECT [tunniste]
Seuraavassa on esimerkki kokonaisluvun merkin selvittvst SELECT CASE

-rakenteesta:
INTEGER :: i, merkki
...
SELECT CASE(i)
CASE (:-1)
merkki = -1
CASE (0)
merkki = 0
CASE (1:)
merkki = 1
END SELECT
Tapausta CASE (:-1) vastaavat negatiiviset kokonaisluvut {1, 2, . . . }, ja

tapausta CASE (1:) vastaavat positiiviset kokonaisluvut {1, 2, . . . }. Jos i on
7. Ohjausrakenteet
89
nolla, saa muuttuja merkki arvon nolla.

Seuraavassa on hiukan monipuolisempi rakenne, jossa testataan alkulukuja:
INTEGER :: i
LOGICAL :: alkuluku
...
SELECT CASE(i)
CASE (2,3,5,7)
alkuluku = .TRUE.
CASE (1,4,6,8:10)
alkuluku = .FALSE.
CASE DEFAULT
alkuluku = testaa(i)
END SELECT
Siis jos luku i on joukossa {2, 3, 5, 7}, saa muuttuja alkuluku arvon tosi.
Jos luku on joukossa {1, 4, 6, 8, 9, 10} saa muuttuja arvon eptosi. Muutoin
(lause CASE DEFAULT) lukua i tutkitaan kyttjn mrittelemss funktiossa testaa, joka selvitt, onko annettu luku alkuluku.
Mys merkkijonoja voi kytt SELECT CASE -rakenteen testeiss:
INTEGER, PARAMETER :: mies = 1, nainen = 2, &
tuntematon = -1
INTEGER :: laji
...
SELECT CASE(nimi)
CASE (Juha, Jussi)
laji = mies
CASE (Maarit, Marita)
laji = nainen
CASE DEFAULT
laji = tuntematon
END SELECT
Merkkej vertaillaan koneen oman merkkikoodin mukaisesti.

Mys merkkijonojen yhteydess voi kytt kaksoispistett vaihtoehtojen
ilmoittamiseen. Esimerkiksi lause
CASE (a:z,,,)
vastaa skandinaavisten merkkien pieni kirjaimia.

CASE-ehdoissa ei saa olla pllekkisi arvoja. Esimerkiksi seuraava on kielletty:
CASE (a:z,,,)
WRITE (*,*) pieni kirjain
CASE (aatami:eeva)
WRITE (*,*) sanakirjan osa 1
Esimerkiksi merkki b vastaa kumpaakin CASE-lauseen ehtoa: merkki kuuluu vlille a:z ja lisksi mys vlille aatami:eeva. Tuloksena on
knnsaikainen virheilmoitus.
90
Fortran 95/2003
Reaalilukumuuttujaa ei voi kytt SELECT CASE -rakenteen ehdoissa, sill

reaalilukujen luettelemisessa ei olisi paljon jrke.
7.4
Toisto: DO-rakenne
Toistoa tarvitaan esimerkiksi seuraavan tyyppisiss tehtviss. Iteraatiokaava

xi+1 = xi
f (xi )
f (xi )
etsii funktion f (x) nollakohtaa ns. Newtonin menetelmll. Seuraavassa ohjelmakoodissa etsitn funktion f (x) = ex + x 5 nollakohtaa alkuarvauksena x0 = 0.
PROGRAM newt
IMPLICIT NONE
CHARACTER(LEN=*), PARAMETER :: muoto = (A,F9.6)
REAL :: x = 0.0
INTEGER :: i, n = 20
WRITE (*,(A,I3)) iteraatioita:, n
WRITE (*,muoto) x:n arvo alussa:, x
DO i = 1, n
x = x - (EXP(x) + x - 5)/(EXP(x) + 1)
WRITE (*,muoto) x:n arvo:, x
END DO
END PROGRAM newt
Toistorakenne aloitettiin DO-lauseella ja lopetettiin END DO -lauseeseen. Ohjelman tulostus voisi olla:
iteraatioita: 20
x:n arvo alussa: 0.000000
x:n arvo: 2.000000
x:n arvo: 1.476812
x:n arvo: 1.317715
x:n arvo: 1.306608
...
x:n arvo: 1.306559
Tss pstiin lhelle nollakohtaa jo neljnnell DO-silmukan toistokerralla.

Muuttujaa i kutsutaan silmukkamuuttujaksi lauseessa
DO i = 1, n
Silmukkamuuttujan on syyt olla kokonaislukutyyppi, sill reaalilukutyyppinen silmukkamuuttuja oli mritelty vanhentuvaksi Fortran 90 -standardin
piirteeksi, ja Fortran 95 -standardista tm piirre on jo poistettu.
DO-rakenteessa voi silmukkamuuttujalle antaa mys erikseen askeleen, mink verran silmukkamuuttujaa muutetaan kullakin iteraatiokierroksella:
DO i = 20, 1, -1
7. Ohjausrakenteet
91
Tss silmukkamuuttuja i saa arvot 20, 19, 18, . . . , 1. Silmukka

DO muuttuja = alku, loppu, askel
suoritetaan

loppu alku + askel
MAX 0, INT
askel
kertaa. Silmukkamuuttuja saa aluksi arvon alku, ja arvoa kasvatetaan lisyksell askel. Jos silmukkamuuttujan arvo ei ole vlill alku . . . loppu, silmukkaa ei en suoriteta.
Esimerkiksi silmukka DO i = 1, 32, 5 suoritetaan

32 1 + 5
MAX 0, INT
=7
5
kertaa ja silmukkaa DO i = 1, 32, -5 ei suoriteta kertaakaan.
Silmukkamuuttujaa ei saa muuttaa silmukan sisll. Silmukkamuuttujan arvoksi j viimeksi testattu arvo, esimerkiksi silmukassa
DO i = 1, 32, 5
lohko
END DO
muuttujan i arvo on silmukan jlkeen 36.

Aina emme tied etukteen, kuinka monta kertaa toistolausetta tytyy suorittaa. Tt varten on olemassa DO-rakenteesta muoto
DO
lohko
END DO
Tllaisenaan kyseess olisi ikuinen silmukka, jonka suoritus ei koskaan lopu.

Kytettviss on kuitenkin EXIT-lause, jolla DO-silmukan suoritus voidaan
lopettaa:
DO
READ (*,*) x
IF (x <= 0) EXIT
summa = summa + x
END DO
Tss luemme lukuja muuttujaan x ja lopetamme silmukan suorituksen,

jos luettu luku ei ole positiivinen. Muussa tapauksessa lismme luetun
lukuarvon muuttujan summa arvoon.
Voimme muuttaa edell esitetyn Newtonin iteraation seuraavaan muotoon:
PROGRAM newt
IMPLICIT NONE
REAL :: x = 0.0, d
REAL, PARAMETER :: toleranssi = 1e3*EPSILON(x)
INTEGER :: i, max_iter = 20
WRITE (*,(A,F9.6)) x:n arvo alussa:, x
DO i = 1, max_iter
92
Fortran 95/2003
d = (EXP(x) + x - 5)/(EXP(x) + 1)
x = x - d
WRITE (*,(A,I3,A,F9.6)) i:, i, , x:n arvo:, x
IF (ABS(d) <= toleranssi*ABS(x)) EXIT
END DO
END PROGRAM newt
Silmukan toistaminen siis lopetetaan, jos muuttujan x arvo muuttuu hyvin

vhn. Silmukalle on mys annettu maksimimr toistokertoja. Tulostus
voisi olla seuraava:
x:n
i:
i:
i:
i:
i:
arvo alussa:
1, x:n arvo:
2, x:n arvo:
3, x:n arvo:
4, x:n arvo:
5, x:n arvo:
0.000000
2.000000
1.476812
1.317715
1.306608
1.306559
Nollakohdan likimriseen lytmiseen tarvittiin viisi iteraatiota.

EXIT-lauseen lisksi kytettviss on CYCLE-lause, joka aloittaa vlittmsti
silmukan seuraavan toistokerran:
summaus: DO
READ (*,*) x
IF (x < 0.0) THEN
EXIT summaus
ELSE IF (x == 0.0) THEN
CYCLE summaus
END IF
summa = summa + 1.0/SQRT(x)
END DO summaus
Tss annettiin silmukkarakenteelle tunniste summaus. Silmukassa luetaan

muuttujalle x arvo, ja jos arvo on negatiivinen, poistutaan silmukasta. Jos
luettu arvo on nolla, siirrytn silmukan seuraavaan toistokertaan. Muussa
tapauksessa lasketaan summalauseke ja jatketaan silmukan toistoa.
Edell on annettu EXIT- ja CYCLE-lauseissa mys silmukan tunniste summaus.
Jos tunnistetta ei ole annettu, lauseet koskevat sisint DO-rakennetta. Tunnisteen avulla voidaan poistua mys ulommasta silmukasta. Kumpaakaan
lauseista EXIT ja CYCLE ei voi kytt DO-silmukan ulkopuolella.
Edellisten DO-rakenteiden lisksi kytettviss on DO WHILE -rakenne, jossa
silmukkaa suoritetaan niin kauan kuin annettu ehto on tosi:
READ (*,*) x
DO WHILE (x > 0)
summa = summa + x
READ (*,*) x
END DO
Testi x > 0 suoritetaan ennen silmukan kutakin toistokertaa. Tm DOrakenne on identtinen aiemmin esitetyn DO-rakenteen kanssa, jossa kytettiin silmukan lopetusehtoa
IF (x <= 0) EXIT
7. Ohjausrakenteet
93
Taulukossa 7.3 on esitetty DO-rakenteen yleinen muoto. Monissa tapauksissa DO WHILE -rakenne on luonnollinen tapa esitt ohjelmalohkon toisto.
Toisinaan selvi kuitenkin helpommin kyttmll EXIT- ja CYCLE-lauseita
DO-rakenteen sisll.
Taulukko 7.3: DO-rakenteen yleinen muoto.
[tunniste:] DO
lohko
END DO [tunniste]
[tunniste:] DO muuttuja = lauseke, lauseke[, lauseke]
lohko
END DO [tunniste]
[tunniste:] DO WHILE (ehto)
lohko
END DO [tunniste]
7.5 Esimerkki: Euklideen algoritmi

Seuraava ohjelma laskee kahden positiivisen kokonaisluvun suurimman yhteisen tekijn (s.y.t.) Euklideen algoritmilla:
PROGRAM syt
! Lasketaan kokonaislukujen m ja n suurin yhteinen
! tekij Euklideen algoritmilla.
IMPLICIT NONE
INTEGER, PARAMETER :: int_kind = SELECTED_INT_KIND(9)
INTEGER (KIND=int_kind) :: m, n, t
WRITE (*,*) Anna positiiviset kokonaisluvut m ja n:
READ (*,*) m, n
WRITE (*,*) m:, m, n:, n
positiivisuusehto: IF (m > 0 .AND. n > 0) THEN
DO WHILE (n /= 0)
t = MOD(m,n)
m = n
n = t
END DO
WRITE (*,*) Suurin yhteinen tekij:, m
ELSE
WRITE (*,*) Luvut eivt ole positiivisia!
END IF positiivisuusehto
END PROGRAM syt
Ohjelmassa kytetn siskkisi ohjausrakenteita. IF-lauseessa tarkistetaan kokonaislukujen positiivisuus:
94
Fortran 95/2003
positiivisuusehto: IF (m > 0 .AND. n > 0) THEN

...
ELSE
WRITE (*,*) Luvut eivt ole positiivisia!
END IF positiivisuusehto
Varsinainen ty tehdn DO WHILE -silmukassa:

DO WHILE (n /= 0)
t = MOD(m,n)
m = n
n = t
END DO
Silmukan sisll lasketaan funktionkutsu MOD(m,n). Tuloksena on jakojnns, joka saadaan, kun m jaetaan n:ll. Sen jlkeen otamme vanhan jakajan
uudeksi jaettavaksi ja jakojnnksen (t) uudeksi jakajaksi. Toisto pttyy,
kun jakojnnkseksi saatu luku on nolla, jolloin viimeisin jakaja on alkuperisten lukujen suurin yhteinen tekij.
Seuraavassa on esimerkki ohjelman kytst:
Anna positiiviset kokonaisluvut m ja n:
88664400 223355000
m: 88664400 n: 223355000
Suurin yhteinen tekij: 2200
7.6
Poikkeusten ksittely
Ohjelmakoodissa tarvitaan toisinaan normaalista poikkeavaa lauseiden suoritusjrjestyst erikoistilanteiden ksittelemiseksi. Usein kyseess on virhetilanne, josta ohjelmakoodin normaali logiikka ei selviydy.
Esimerkiksi silmukoista psee ulos EXIT-lauseella. Voit ksitell erikoistilanteita yhdistmll loogisia muuttujia ja IF-rakenteita:
LOGICAL :: tilanne_ok = .TRUE.
lohko1
IF (tilanne_ok) THEN
! normaali tilanne
lohko2
ELSE
! erikoistilanne
lohko3
END IF
Jos ensimmisess lohkossa tapahtuu jotain yllttv, asetetaan muuttujan

tilanne_ok arvoksi .FALSE.. Loppuosassa ohjelmayksikn koodia voidaan
tm tapaus ksitell erikseen IF-lauseen avulla. Voit kytt mys SELECT
CASE -rakennetta erikoistilanteiden ksittelyyn.
Erittin vakavien virheiden tapahtuessa voidaan ohjelman suoritus keskeytt STOP-kskyll. Aliohjelmasta tai funktiosta voi palata kutsuvaan ohjelmaan lauseella RETURN (aliohjelmista ja funktioista kerrotaan luvussa 8).
7. Ohjausrakenteet
95
7.7 Hyppylause: GOTO-lause

Hyppylause voi toisinaan soveltua poikkeusten ksittelyyn. Hyppylause siirt suorituksen ohjelmayksikn toiseen lauseeseen. Hyppylauseen kohde
tunnistetaan lausenumerolla. Usein hyppylauseen kohteena kytetn erityist CONTINUE-lausetta, joka ei tee mitn muuta kuin jatkaa suoritusta
seuraavasta lauseesta.
Seuraavassa on esimerkki hyppylauseen kytst:
! Tarkistetaan virhetilanne
IF (testi) GOTO 99
lohko1
99 CONTINUE
lohko2
Tss siis siirryttiin lauseeseen 99, jos ehto testi oli tosi. Huomaa, ett saman voi usein tehd IF-rakenteella. GOTO-lause voi olla kuitenkin joskus
tarpeen poistuttaessa siskkisten ohjausrakenteiden keskelt. Tsskin tapauksessa esimerkiksi DO-silmukan EXIT-lause on parempi ohjausrakenne
kuin GOTO, koska kntj pystyy optimoimaan DO-silmukkarakenteen suoritusta, mutta ei GOTO-lauseita.
Hyppylauseen normaalit muodot ovat
GOTO lausenumero
GO TO lausenumero
Hyppylauseen kohteena olevan lauseen tulee alkaa lausenumerolla:

lausenumero CONTINUE
lausenumero lause
Lausenumerossa on yhdest viiteen desimaalinumeroa, joista yhden tulee

olla nollasta poikkeava. Numeron alussa olevia nollia ei lasketa mukaan erotettaessa lausenumeroita toisistaan.
Hyppylausetta voi kytt siirtymiseen ulos ohjausrakenteesta, mutta hyppminen DO-silmukan tai muun ohjausrakenteen sislle on kielletty. Kuitenkin lohkon sisiset hyppylauseet ovat sallittuja, samoin hypyt lohkon
sislt ohjausrakenteen lopetuslauseeseen.
Vanhoissa Fortran-koodeissa on kytetty GOTO-lauseita toistorakenteiden tai
SELECT CASE -rakenteen simulointiin. Nm GOTO-rakenteet on syyt korvata paremmilla ohjausrakenteilla koodin selkeyden takia, mutta mys tehokkuussyist: kntj ei yleens pysty optimoimaan GOTO-kskyj sisltv
koodia.
7.8 Tiedonsiirron erikoistilanteet

Lausenumeroita voidaan joutua kyttmn mys tiedonsiirron erikoistilanteissa (tst kerrotaan tarkemmin kappaleessa 12.11 sivulla 210).
96
Fortran 95/2003
Usein selvimme kuitenkin kyttmll tilamuuttujaa. Seuraavassa on esimerkki syttoperaation erikoistilanteen ksittelyst:
INTEGER :: tila
tila = 0
READ (*,*,IOSTAT=tila) luku
IF (tila == 0) THEN
Tehdn normaali operaatio
ELSE
Virheen ksittely
END IF
Jos READ-lauseessa tapahtui virhe, saa muuttuja tila nollasta poikkeavan

arvon.
7.9
Yhteenveto
Fortran-kieli sislt kattavan valikoiman ohjausrakenteita lauseiden suoritusjrjestyksen muuttamiseksi. Erityisesti IF- ja SELECT CASE -rakenteet sek DO-silmukka mahdollistavat monimutkaisenkin ohjelmalogiikan selken
toteuttamisen.
Harjoitustehtvi
1. Mit seuraava koodirivi tekee?
IF (x /= 0.0) y = 1/x; z = y/x
2. Kirjoita SELECT CASE -rakenne, joka tekee kolme erityyppist toimintoa

sen mukaan, onko kokonaislukumuuttuja negatiivinen, nolla tai jokin
alkuluvuista (3, 5, 7, 11, 13). Muussa tapauksessa ei tehd mitn.
3. Ilmoita seuraavien DO-silmukkojen toistokertojen lukumr, silmukkamuuttujan i saamat arvot silmukan sisll sek silmukkamuuttujan
arvo DO-rakenteen jlkeen.
DO
DO
DO
DO
DO
i
i
i
i
i
=
=
=
=
=
1, 5
5, 0, -1
10, 1, -2
0, 30, 7
3, 2, 1
4. Kirjoita DO-silmukka, joka summaa 100 annetun reaaliluvun nelijuuret

poislukien negatiiviset luvut ja lopettaa summauksen, jos summattava
luku on pienempi kuin 1000.
5. Muuta suurimman yhteisen tekijn laskevaa ohjelmaa (katso kappaletta
7.5 sivulla 93) siten, ett ohjelma laskee ja tulostaa algoritmin tarvitsemien DO-silmukan toistokertojen lukumrn.
7. Ohjausrakenteet
97
Tarkista mys Lamn lause, jonka mukaan syt(m,n) vaatii korkeintaan

5*LOG10(max(m,n)) MOD-laskua.
6. Tulosta muunnostaulu tuumista millimetreihin (1" = 25.4 mm). Aloita
arvosta 0.0 ja tulosta arvoja puolen tuuman vlein 12 tuumaan asti.
7. Ratkaise toisen asteen yhtln ax 2 +bx +c = 0 reaaliset juuret kytten
apuna ratkaisukaavaa
x=
b2 4ac
.
2a
(7.1)
Tss a, b ja c ovat reaalilukuja. Jos ptee ehto b2 4ac = 0, on yhtlll vain yksi juuri, ja jos ptee ehto b2 4ac < 0, ei yhtlll ole
reaaliarvoisia juuria. Lue ohjelmassasi vakioiden a, b, c arvot ptteelt,
ja tarkista yhtln ratkaisujen lukumr ennen juurien laskemista.
Huomaa, ett termit b2 ja 4ac voivat aiheuttaa ylivuodon, jos kertoimet
ovat hyvin suuria. Ylivuodon voi vltt skaalaamalla yhtln suurimmalla kertoimella.
Termin b ja diskriminantin b2 4ac vlisess yhteen- tai vhennyslaskussa tapahtuvan pyristysvirheen voi minimoida kyttmll seuraavia ratkaisukaavoja:
diskr = SQRT(b**2-4*a*c)
q = -(b + SIGN(diskr,b))/2
j1 = q/a
j2 = c/q
Vertaile niden kaavojen ja yhtlss (7.1) esitetyn ratkaisukaavan tarkkuutta. Voit kytt esimerkkin yhtl x 2 bx + 1 = 0, kun kerroin
b
1.
8. Ns. Collatzin probleemassa tarkastellaan iteraatiota

ni+1 =
ni /2,
ni parillinen,
(3ni + 1)/2, ni pariton,
miss i = 0, 1, . . . , . Tss oletetaan, ett alkuarvo n0 > 0.

Jos n0 = 3, tuottaa iteraatio arvot
n1 = 5,
n2 = 8,
n3 = 4,
n4 = 2,
n5 = 1,
n6 = 2.
Siis iteraatio ptyy vuorottelemaan lukujen 1 ja 2 vlille. Nin ky kaikille positiivisille kokonaisluvuille (tt ei kuitenkaan ole matemaattisesti todistettu!).
Kirjoita ohjelma, joka laskee sykliin {1, 2} ptymiseen tarvittavien toistojen lukumrn luvuille n0 {1, 2, . . . , 100}.
9. Laajenna edellisen tehtvn ohjelmaa siten, ett iteraation alkuarvoksi
n0 ky mys negatiivinen kokonaisluku tai nolla. Laske, kuinka monta
iteraatiota tarvitaan, kunnes annetusta kokonaisluvusta (positiivinen tai
98
Fortran 95/2003
negatiivinen) pstn johonkin seuraavista sykleist:

S1 = {0}
S2 = {1}
S3 = {1, 2}
S4 = {5, 7, 10}
S5 = {17, 25, 37, 55, 82, 41, 61, 91, 136, 68, 34}.
Laske sykleihin ptyvien iteraatioiden pituudet, kun alkuarvoina n0 on
luvut {0, 1, 2, . . . , 100}.
10. Muuta seuraava GOTO-kskyj kyttv ohjelmakoodi IF-rakenteeksi:
INTEGER :: i, m, a, b
IF (i .EQ. 1) GOTO 100
IF (i .EQ. 3) GOTO 200
m = m + a
GOTO 500
100 m = m + b
GOTO 500
200 m = m - b
500 CONTINUE
Kumpi ohjelmakoodi on mielestsi selkempi?

11. Kirjoita funktio MSUM(f,n), joka summaa funktion f (i), i = 1, 2, . . . , n,
arvot maagisella summauksella (harjoitustehtv 11 sivulla 65). Funktio
f on tyyppi REAL. Laske summa mys kytten standardifunktiota SUM.
Tutki funktiota MSUM seuraavan sarjan avulla:
(1)k1
.
k
k=1
Mrittele kaksi eri tarkkuuden reaalilukulajia seuraavasti:

INTEGER, PARAMETER :: sp = KIND(1.0)
INTEGER, PARAMETER :: dp = &
SELECTED_REAL_KIND(2*PRECISION(1.0))
Mrittele tmn jlkeen taulukot arvot (laji sp) ja tarkat_arvot (laji

dp), joihin on laskettu funktion n ensimmist arvoa. Tulosta nyt seuraavien lausekkeiden arvot:
|SUM(arvot) SUM(tarkat_arvot)|
|MSUM(f,n) SUM(tarkat_arvot)|.
8. Funktiot ja aliohjelmat
99
Funktiot ja aliohjelmat
Kerromme tss luvussa Fortranin funktioiden ja aliohjelmien mrittelyst ja kytst. Funktioita ja aliohjelmia kutsutaan Fortran 95:ss yhteisell
nimell proseduurit. Itse mrittelemiesi proseduurien lisksi voit kytt
Fortranin standardiproseduureja.
8.1 Tehtvn jakaminen osiin

Tehtvn jakaminen pienempiin osiin on yleens paras lhestymistapa ratkaistessasi vhnkin suurempia tehtvi. Ohjelmankehityksess puhutaan
ksitteist top down ja bottom up, jotka kuvaavat, miss jrjestyksess tehtv jaetaan osiin.
Liikkeelle voi lhte ylhlt eli koko tehtvn tasolta. Tllin seuraavassa
vaiheessa ratkaistavana on muutama pienempi ja toivottavasti helpommin
ratkeava tehtv.
Toinen lhestymistapa on aloittaminen ruohonjuuritasolta, jolloin aluksi kirjoitetaan pieni apu- ja tykaluproseduureja. Nist osasista kootaan lopullisen tehtvn ratkaiseva ohjelmakoodi.
Yleens ohjelmankehityksess tarvitaan kumpaakin lhestymistapaa. Trkeint on ohjelmakoodin huolellinen ennakkosuunnittelu ja jo alkuvaiheissa aloitettu testaaminen.
Ohjelmankehityksess voi soveltaa komponenttiajattelua, jossa pyritn kehittmn mahdollisimman itsenisi ja uudelleen kytettviss olevia tykaluja. Ideana on mritell kunkin komponentin kutsurajapinta muihin ohjelmayksikihin sek komponentin tekemt operaatiot, mutta toteutuksen
yksityiskohdat piilotetaan ulkopuolisilta. Tllin voimme muuttaa toteutusta myhemmin ilman, ett komponenttiamme kyttvi ohjelmayksikit
tarvitsee mys muuttaa.
Fortran 95 -kieli tarjoaa hyvt mahdollisuudet ohjelmistokomponenttien
tuottamiseen. Tss luvussa esiteltvien aliohjelmien ja funktioiden lisksi kytettviss on seuraavassa luvussa (sivu 126) esiteltvt moduulit. Moduulien avulla voidaan proseduureja ja niihin liittyv dataa paketoida itsenisiksi kokonaisuuksiksi.
100
8.2
Fortran 95/2003
Proseduurit, funktiot ja aliohjelmat
Fortran 95:n yhteydess tarkoitetaan proseduurilla (procedure) joko funktiota (function) tai aliohjelmaa (subroutine). Funktio palauttaa arvon, joten
funktioita kytetn Fortranin lausekkeiden osana. Aliohjelma sen sijaan
siirt tietoa ainoastaan argumenttiensa vlityksell.
Fortranin ksitteist eroaa tlt osin esimerkiksi Pascal-kielen yhteydess
kytetyst terminologiasta: Pascalissa aliohjelma on yleisnimi funktioille ja
proseduureille. Kytmme Fortran-standardin mukaista terminologiaa, jotta Fortran-ohjelmakoodin kirjoittaminen ja lukeminen olisi helpompaa (esimerkiksi sanaa procedure kytetn Fortranin lauseiden osana). Lisksi
mys englanninkielisten ksikirjojen lukeminen on helpompaa, kun ksitteist on tuttu.
8.3
Mihin proseduureja kytetn
Proseduureja kyttmll tehtv voidaan jakaa pienempiin, nimettyihin

osatehtviin. Proseduurien kytt paitsi helpottaa ohjelman hahmottamista mys parantaa ohjelman yllpidettvyytt: usein tarvitsee muuttaa vain
osaa ohjelmakoodin proseduureista. Esimerkiksi muutettaessa ohjelman tulostusproseduureja ei vlttmtt tarvitse muuttaa ohjelman laskentaosaa,
ja pinvastoin.
Ohjelman jakaminen itsenisiin proseduureihin helpottaa mys ohjelmakoodin testausta. Kutakin proseduuria voidaan testata erikseen, ja vian lytyess se voidaan usein paikallistaa tiettyyn proseduuriin.
Fortran-kielt on kytetty jo vuosikymmeni ohjelmistoteollisuuden vlineen. Ohjelmoijan kytettviss onkin monipuolinen valikoima valmiita proseduureja. Saatavilla on esimerkiksi aliohjelmakirjastot IMSL ja NAG, jotka
sisltvt kumpikin yli tuhat proseduuria tieteellisen ja teknisen laskennan
perustehtviin. Fortran 95 -kieleen kuuluu 115 standardiproseduuria, joista
kerrotaan luvussa 13 (sivu 215).
Hyvin testattujen ja korkealaatuisten aliohjelmakirjastojen kytt sst
ohjelmoijan tyaikaa ja tuottaa yleens tehokkaita ja luotettavia ohjelmia.
Ei kannata keksi pyr uudestaan, kun se kerran on jo keksitty!
8.4
Funktioiden mrittely ja kytt
Funktioita kytetn Fortran-lausekkeissa tarvittavien arvojen laskemiseen.

Seuraavassa on esimerkki funktiosta, joka palauttaa arvonaan argumenttina
annetun kokonaisluvun i numeroiden mrn desimaalijrjestelmss:
101
FUNCTION desimaalit(i) RESULT(desim)

IMPLICIT NONE
INTEGER :: i, desim
INTEGER :: apu
INTRINSIC ABS
desim = 1
apu = ABS(i)
DO WHILE (apu >= 10)
apu = apu/10
desim = desim + 1
END DO
END FUNCTION desimaalit
Funktion mrittely alkaa otsikkolauseella

FUNCTION tunnus(argumenttilista) RESULT(tunnus)
RESULT-mrittelyss esitelty tunnusta kytetn funktion palauttaman arvon mrittelemiseen. Myhemmin esittelemme otsikkolauseen vaihtoehtoisia muotoja.
Funktion arvo palautetaan kokonaislukumuuttujassa desim, joka on mainittu RESULT-mrittelyss. Tt muuttujaa saa kytt normaalin muuttujan
tapaan funktion sisll. Muuttujan desim viimeksi saama arvo palautetaan
funktiokutsun arvona.
Kokonaislukumuuttuja i on desimaalit-funktion muodollinen argumentti.
Huomaa, ett funktio desimaalit ei muuta muodollisen argumenttinsa i
arvoa!
Funktion sisll mritelty muuttuja apu on paikallinen muuttuja, joka on
kytettviss vain funktion sisll. Funktiossa voi vapaasti mritell paikallisia muuttujia avuksi tarvittaviin laskentaoperaatioihin.
Voimme kytt funktiota desimaalit pohjelman sisisen funktiona seuraavasti:
PROGRAM desit
IMPLICIT NONE
INTEGER :: n
WRITE (*,*) Anna n:
READ (*,*) n
WRITE (*,*) Luku n: , n
WRITE (*,*) Desimaaleja: , desimaalit(n)
CONTAINS
Funktion desimaalit edell esitetty mrittely
END PROGRAM desimaalit
Funktion desimaalit mrittely tulee sijoittaa CONTAINS-lauseen jlkeen

pohjelman loppuun. Jos sisisi proseduureja on enemmn kuin yksi, ne
mritelln perkkin. Sisisill proseduureilla ei voi olla omia sisisi proseduureja.
Lauseke desimaalit(n) on funktiokutsu, ja muuttujaa n sanotaan funktion todelliseksi argumentiksi. Funktiokutsun desimaalit(n) vaikutuksesta
102
Fortran 95/2003
funktion desimaalit muodollinen argumentti i saa arvokseen muuttujalla

n kutsuhetkell olevan arvon.
Seuraavassa on ohjelman desit kyttesimerkkej:
Anna n:
10101
Luku n:
Desimaaleja:
Anna n:
-199
Luku n:
Desimaaleja:
10101
5
-199
3
Koska Fortranin kokonaislukutyypill voi esitt vain rellisen kokoisia lukuja, ohjelmalle ei voi sytt mielivaltaisen pitki kokonaislukuja.
On mahdollista mritell mys funktio, jolla ei ole yhtn argumenttia. Sulkumerkkej on kuitenkin kytettv sek funktion mrittelyss ett kutsussa:
PROGRAM funtesti
IMPLICIT NONE
WRITE (*,*) Satunnaisluku: , rnd()
CONTAINS
FUNCTION rnd()
IMPLICIT NONE
REAL :: rnd
CALL RANDOM_NUMBER(rnd)
END FUNCTION rnd
END PROGRAM funtesti
Mrittelimme pohjelmalle sisisen funktion rnd, joka palauttaa arvonaan

tasajakautuneen satunnaisluvun vlilt [0, 1). Apuna kytmme standardialiohjelmaa RANDOM_NUMBER.
8.5
Funktion otsikkolauseen muodot
Edell esittelimme RESULT-lausekkeessa funktion arvon palauttavan muuttujan. Paluuarvon sisltv muuttuja voi olla saman niminen kuin funktio.
Tm onnistuu jttmll RESULT-lauseke pois:
FUNCTION desimaalit(i)
IMPLICIT NONE
INTEGER :: i, desimaalit
Tss mriteltiin funktion desimaalit tyypiksi kokonaislukutyyppi. Tyyppimrittelyn voi antaa mys osana otsikkolausetta:
INTEGER FUNCTION desimaalit(i)
Tllin ei en saa mritell desimaalit-nimist muuttujaa.
103
RESULT-lausekkeen kytt on tarpeen erityisesti rekursiivisten (itsen kutsuvien) funktioiden tapauksessa. Tst kerrotaan lis kappaleessa 8.12 (sivu 111).
Tyyliseikoista voi olla monta mielt, mutta useimmiten RESULT-lausekkeen
kytt selkeytt ohjelmakoodia.
8.6 Funktion sivuvaikutukset

Seuraavassa ksittelemme funktioiden mahdollisia sivuvaikutuksia. Hyvss
ohjelmointityyliss funktioilla ei ole sivuvaikutuksia.
Funktion ei yleens ole syyt muuttaa argumenttiensa arvoja. Edell mritelty funktio desimaalit voitaisiin mritell virheellisesti seuraavasti:
IMPLICIT NONE
INTEGER :: i, desim
INTRINSIC ABS
desim = 1
i = ABS(i)
DO WHILE (i >= 10)
i = i/10
desim = desim + 1
END DO
Tss kytmme laskentaan muodollista argumenttia i lauseissa

i = ABS(i)
ja
i = i/10
Tllin muuttuu mys funktiokutsussa annetun todellisen argumentin arvo.

Esimerkiksi lauseen
suorittamisen jlkeen olisi argumentin n arvo vlill [0, 9].

Entp mik olisi seuraavien lausekkeiden vaikutus:
desimaalit(10*n) + desimaalit(n+1)
desimaalit(1996)
Muuttuisiko muuttujan n arvo ylemmiss funktiokutsuissa? Tai muuttuisiko

vakion 1996 arvo? Nist syist funktioilla ei tulisi olla sivuvaikutuksia, eli
niiden ei tulisi muuttaa argumenttiensa arvoja.
Sivuvaikutuksen voi aiheuttaa mys vaikkapa funktion kutsukertoja laskevan muuttujan pivittminen funktion sisll sek funktiossa tehdyt tiedonsiirto-operaatiot (WRITE-lause jne.).
104
Fortran 95/2003
Seuraavassa on esimerkki tulostusoperaatiosta, jossa kytetn funktiota

desimaalit:
Jos funktiossa desimaalit suoritetaan ptteelle tulostava WRITE-lause,

seurauksena on ajonaikainen virhetilanne, sill kytss on tllin kaksi
siskkist WRITE-lausetta.
8.7
Aliohjelmien mrittely ja kytt
Edellisess kappaleessa esitellyt funktiot palauttavat (yleens) vain funktiokutsun arvon eivtk muuta argumenttiensa arvoja. Usein tarvitaan tt monipuolisempaa tiedonsiirtoa proseduurin ja kutsuvan ohjelman vlill. Tt
varten Fortranissa voidaan mritell ja kytt aliohjelmia (subroutine).
Aliohjelman nimi mritelln SUBROUTINE-lauseessa, ja aliohjelmaa kutsutaan CALL-lauseella. Seuraavassa mrittelemme aliohjelman vaihda kahden reaaliluvun arvojen vaihtamiseksi keskenn:
SUBROUTINE vaihda(a,b)
IMPLICIT NONE
REAL :: a, b
REAL :: apu
apu = a
a = b
b = apu
END SUBROUTINE vaihda
Vaihdamme aliohjelman muodollisten argumenttien a ja b arvot keskenn

kytten apuna paikallista reaalilukumuuttujaa apu. Aliohjelmaa vaihda
voisi kytt seuraavasti:
PROGRAM vaihtotesti
IMPLICIT NONE
REAL :: x = 1.0, y = -1.0
WRITE (*,*) x,y: , x, y
IF (x > y) THEN
CALL vaihda(x,y)
END IF
WRITE (*,*) x,y: , x, y
CONTAINS
Aliohjelman vaihda edell annettu mrittely
END PROGRAM vaihtotesti
Aliohjelmakutsu tehdn pohjelman lauseessa

CALL vaihda(x,y)
Ohjelman tulostus voisi olla

x,y:
x,y:
1.000000
-1.000000
-1.000000
1.000000
105
8.8 Todellisten ja muodollisten argumenttien

vastaavuus
Muutettaessa Fortranin proseduurien muodollista argumenttia muuttuu todellisen argumentin arvo. Erityisesti funktion tapauksessa tm voi johtaa
vaikeasti jljitettviin virhetilanteisiin. Virheiden vlttmiseksi on hyv kytt seuraavassa kappaleessa esiteltvi muodollisten argumenttien INTENTmreit.
Proseduurin todellisten ja muodollisten argumenttien tulisi vastata toisiaan
tyypiltn ja tarkkuudeltaan. Jos muodollista argumenttia muutetaan proseduurissa, tulee vastaavan todellisen argumentin olla muuttuja tai viittaus
taulukkomuuttujan tai rakenteisen muuttujan alkioon.
Fortranin proseduurikutsuissa ei tehd automaattisia tyypinmuunnoksia kuten esimerkiksi aritmeettisissa lausekkeissa. Mrittelemme esimerkin vuoksi funktion f seuraavasti:
FUNCTION f(x) RESULT(f_arvo)
IMPLICIT NONE
REAL :: x, f_arvo
f_arvo = EXP(x) + x - 5
END FUNCTION f
Nyt seuraavat funktiokutsut ovat virheellisi:

f(3)
f((1,0))
f(auto)
kokonaislukuargumentti
kompleksilukuargumentti
merkkitieto
Proseduureihin voi vlitt ns. oletetun pituisia merkkijonoja ja vaihtelevan

kokoisia taulukoita. Taulukkojen kytst proseduureissa kerrotaan enemmn luvussa 11 (sivu 164).
Seuraavassa on esimerkki funktiosta isot_merkit, joka muuttaa argumenttinaan saamansa merkkijonon isoiksi kirjaimiksi:
PROGRAM mjono_testi
IMPLICIT NONE
WRITE (*,*) isot_merkit(Merkkijono)
CONTAINS
FUNCTION isot_merkit(mjono) RESULT(uusi)
IMPLICIT NONE
CHARACTER(LEN=*) :: mjono
CHARACTER(LEN=LEN(mjono)) :: uusi
INTEGER, PARAMETER :: ero = IACHAR(A) - IACHAR(a)
INTEGER :: i
uusi = mjono
DO i = 1, LEN_TRIM(uusi)
SELECT CASE (uusi(i:i))
CASE(a:z)
uusi(i:i) = CHAR(IACHAR(uusi(i:i)) + ero)
END SELECT
106
Fortran 95/2003
END DO
END FUNCTION isot_merkit
END PROGRAM mjono_testi
Oletetun pituinen merkkijonoargumentti mjono on mritelty kytten merkint LEN=*. Funktio palauttaa merkkijonon uusi, joka on yht pitk kuin
argumentti mjono:
CHARACTER(LEN=LEN(mjono)) :: uusi
Funktiossa ei muuteta kirjaimia , ja isoiksi kirjaimiksi. Tm on harjoitustehtvn.
8.9
Tiedon vlittminen proseduureihin
Proseduurin mrittelyss on mahdollista kertoa, mihin suuntaan kukin proseduurin argumenteista siirt tietoa. Tm onnistuu kyttmll INTENTmrett. Seuraavassa aliohjelman mrittelyss kerromme, ett argumentit a ja b siirtvt tietoa kutsuvasta ohjelmayksikst sek aliohjelmaan ett
takaisin pin:
SUBROUTINE vaihda(a,b)
IMPLICIT NONE
REAL, INTENT(INOUT) :: a, b
REAL :: apu
apu = a
a = b
b = apu
Mrittely INTENT(INOUT) kertoo, ett aliohjelma vaihda kytt muodollisten argumenttien aliohjelmakutsussa saamia arvoja. Lisksi aliohjelma
muuttaa vastaavien todellisten argumenttien arvoja palattaessa aliohjelmasta kutsuvaan ohjelmayksikkn.
Jos INTENT-mreit ei ole annettu, kntj ei tarkista proseduurin argumenttien kytttapaa. Lisksi INTENT-mre auttaa hahmottamaan ohjelman toimintaa: mre kertoo, mihin suuntaan tietoa siirretn proseduurin
kussakin argumentissa.
INTENT-mritteen kytt est esimerkiksi seuraavan virheellisen aliohjelmakutsun:
CALL vaihda(1.0,2.0)
Tss vlitetn vaihda-aliohjelmaan kaksi vakiota vaihdettaviksi keskenn. Muodollisten argumenttien INTENT(INOUT)-mre johtaa tss tapauksessa knnsaikaiseen virheeseen, koska vakioiden muuttaminen on
kielletty.
INTENT-mreen vaihtoehtoiset muodot ovat
INTENT(IN)
INTENT(OUT)
siirretn tietoa sisn aliohjelmaan

siirretn tietoa ulos aliohjelmasta
INTENT(INOUT)
INTENT(IN OUT)
107
siirretn tietoa molempiin suuntiin

siirretn tietoa molempiin suuntiin
Voimme muuttaa edell esitetty funktion desimaalit mrittely seuraavasti:

IMPLICIT NONE
INTEGER, INTENT(IN) :: i
INTEGER :: desim
INTEGER :: apu
INTRINSIC ABS
desim = 1
apu = ABS(i)
apu = apu/10
desim = desim + 1
END DO
Mrite INTENT(IN) est muuttujan i muuttamisen funktion sisll. Tm

eliminoi funktion tahattomat sivuvaikutukset. Tss tapauksessa funktiokutsu
desimaalit(1996)
on tysin luvallinen, koska INTENT(IN)-mrite takaa, ettei funktio muuta

muodollista argumenttia i. Jos funktion koodiin olisi pujahtanut esimerkiksi
sijoituslause
i = ABS(i)
johtaa tm knnsaikaiseen virheilmoitukseen, koska argumentin i muuttaminen on kielletty.
8.10 Paikallisten muuttujien silyminen

Toisinaan olisi hyv, ett proseduurin paikallisen muuttujan arvo silyisi
kutsukertojen vlill. Olkoon esimerkkin seuraava funktio:
PROGRAM neliosumma
IMPLICIT NONE
WRITE (*,*) tulos: , nesu(1.0)
WRITE (*,*) tulos: , nesu(2.0)
CONTAINS
REAL FUNCTION nesu(x)
IMPLICIT NONE
REAL, INTENT(IN) :: x
REAL, SAVE :: nsum = 0.0
nsum = nsum + x**2
nesu = nsum
END FUNCTION nesu
END PROGRAM neliosumma
108
Fortran 95/2003
Funktio nesu laskee argumenttina x annettujen lukujen kumulatiivista nelisummaa kutsukerrasta toiseen.
Alustamme sisisen funktion paikallisen muuttujan nsum arvoltaan nollaksi
ja annamme muuttujalle mreen SAVE. Tmn johdosta muuttuja nsum saa
arvon 0.0 kutsuttaessa funktiota nesu ensimmisen kerran. Tmn jlkeen
muuttujan nsum arvo silyy funktiokutsujen vlill.
Edellisen ohjelman tulostus on
tulos:
tulos:
1.0000000
5.0000000
Edell kytettiin SAVE-mrett muuttujan arvon silyttmiseen funktion

kutsukertojen vlill. Asian olisi hoitanut mys mrittely
REAL :: nsum = 0.0
sill mrittelyss alustetut paikalliset proseduurin muuttujat oletetaan automaattisesti SAVE-tyyppisiksi.

Siis proseduurin paikallisen muuttujan arvo alustetaan mrittelylauseessa
vain kerran! Alustamattoman paikallisen muuttujan alkuarvo on mrittelemtn, eik muuttujan arvo sily kutsukertojen vlill, ellei kytet SAVEmrett.
Jos haluat, ett muuttujan arvo alustetaan aina proseduuria kutsuttaessa,
kyt suoritettavaa sijoituslausetta:
REAL :: nsum
nsum = 0.0
8.11
Sisiset ja ulkoiset proseduurit
Tss luvussa on thn asti kytetty yksinomaan pohjelman sisisi proseduureja (internal procedure). Ne mritelln pohjelman lopussa lauseen
CONTAINS jlkeen.
Sisisten proseduurien lisksi Fortranissa voi mritell ja kytt ulkoisia
proseduureja (external procedure) ja moduulin proseduureja (module procedure). Seuraavassa kerromme tarkemmin sisisist ja ulkoisista proseduureista. Moduulien kytt esitelln luvussa 9 (sivu 126).
8.11.1 Sisiset proseduurit

Sisiset proseduurit mritelln ohjelmayksikn lopussa CONTAINS-lauseen
jlkeen. Sisisill proseduureilla ei voi olla omia sisisi proseduureja.
Sisinen proseduuri mritelln isnnksi (host) kutsutun ohjelmayksikn sisll. Isntn voi toimia pohjelma, ulkoinen proseduuri tai moduulin proseduuri.
109
Sisiset proseduurit voivat kytt hyvksi isnnss mriteltyj muuttujia

ja muita olioita. Poikkeuksena on sellainen tilanne, jossa isnnss mritelty nime kytetn mys sisisen proseduurin paikallisena tunnuksena.
Seuraavassa on esimerkki pohjelmassa mritellyn muuttujan kytst
sisisess aliohjelmassa:
PROGRAM vaihtotesti
IMPLICIT NONE
REAL, DIMENSION(3) :: taulu = (/ 0.5, -0.5, 1.0 /)
WRITE (*,*) taulu
CALL vaihda(1,2)
WRITE (*,*) taulu
CONTAINS
SUBROUTINE vaihda(i,j)
IMPLICIT NONE
INTEGER, INTENT(IN) :: i, j
REAL :: apu
apu = taulu(i)
taulu(i) = taulu(j)
taulu(j) = apu
END PROGRAM vaihtotesti
Pohjelmassa vaihdetaan kolmialkioisen taulukon taulu ensimminen ja

toinen alkio keskenn aliohjelmakutsulla
CALL vaihda(1,2)
Taulukkoa taulu kutsutaan pohjelman globaaliksi muuttujaksi, koska siihen voidaan viitata mys sisisist aliohjelmista. Globaaleja muuttujia tulisi
kytt harkiten, jottei synny tarpeettomia riippuvuuksia ohjelmayksikiden vlille.
Muuttuja apu on aliohjelman vaihda paikallinen muuttuja, eik se ny pohjelmaan tai pohjelman muihin sisisiin proseduureihin.
Aliohjelman vaihda mrittelyst voisi jtt pois lauseen
IMPLICIT NONE
sill pohjelmassa annettu lause vaikuttaa mys sisisiin proseduureihin.

Kuitenkin tm lause kannattaa sijoittaa mys sisisiin proseduureihin.
Muussa tapauksessa lause on erikseen muistettava list, jos sisisen proseduurin mrittely jatkossa siirretn tai kopioidaan ulkoiseksi tai moduulin
proseduuriksi.
Aliohjelma vaihda pystyy ksittelemn pohjelman taulukkoa taulu, koska aliohjelmassa ei ole mritelty saman nimist paikallista tunnusta. Jos
pohjelmassa olisi mritelty tunnus nimelt apu, ei tt tunnusta vastaava olio olisi kytettviss aliohjelmassa vaihda, koska aliohjelmassa on
mritelty paikallinen muuttuja apu.
Ohjelmayksikss nkyville tunnuksille on siis sisin mrittely se, joka on
kulloinkin voimassa.
110
Fortran 95/2003
8.11.2 Ulkoiset proseduurit

Ulkoiset proseduurit (external procedure) olivat ainoa Fortranin aikaisempien versioiden tuntema proseduurityyppi. Fortran 95:n yhteydess ulkoisia proseduureja tarvitaan lhinn kytettess valmiita aliohjelmakirjastoja. Yleens kannattaa kytt moduuleihin sijoitettuja proseduureja. Toinen
ulkoisten proseduurien kytttarve on kutsuttaessa Fortranista muilla ohjelmointikielill kirjoitettuja funktioita ja aliohjelmia.
Ulkoiset proseduurit tulee mainita ohjelmayksikn alussa EXTERNAL-lauseessa. Jos kyseess on funktio, tytyy lisksi mritell funktion palauttaman
arvon tyyppi. Tm onnistuu kyttmll EXTERNAL-mrett. Seuraavassa
on esimerkki ulkoisen funktion desimaalit kytst:
PROGRAM ulkolainen
IMPLICIT NONE
INTEGER :: n
INTEGER, EXTERNAL :: desimaalit
WRITE (*,*) Anna n:
READ (*,*) n
WRITE (*,*) Luku n: , n
END PROGRAM ulkolainen
Ulkoinen funktio desimaalit tytyy knt erikseen ja linkitt pohjelman kanssa ajokelpoiseksi ohjelmaksi.
Koska ulkoinen aliohjelma ei palauta arvoa, tytyy mrittelyyn kytt tyypinmrittelylauseen sijaan EXTERNAL-lausetta vaikkapa seuraavasti:
EXTERNAL vaihda
8.11.3 Knnsaikaiset virheentarkistukset

Ulkoiset proseduurit eivt tarjoa samanlaista virheentarkistusta kuin sisiset tai moduulin proseduurit. Tmn vuoksi olisi aina pyrittv kyttmn
joko sisisi proseduureja tai moduulissa mriteltyj proseduureja.
Edellisess pohjelmassa voisi esiinty seuraavat ulkoisten funktioden kutsut ilman, ett kntj havaitsee virhett:
desimaalit(100.0)
desimaalit(1,2)
Ensimmisess funktiokutsussa vlitetn funktioon desimaalit reaalilukuvakio, vaikka funktiossa oletetaan ksiteltvn kokonaislukudataa. Toisessa tapauksessa vlitetn funktiokutsussa kaksi argumenttia, vaikka funktio tarvitsee vain yhden argumentin.
Kappaleessa 8.16 sivulla 116 kerrotaan lis kntjn tekemist proseduurien argumenttilistojen tarkistuksista.
Jos funktio on mritelty sisisen tai moduulin funktiona, huomaa kntj
111
edell esitetyn tapaiset virheet. Tllin kntj tarkistaa mm. proseduurien

argumenttien lukumrn, tyypin ja INTENT-mritteiden noudattamisen.
8.12
Rekursio
Ohjelmoinnissa tarkoitetaan rekursiolla sit, ett proseduuri kutsuu itsen

joko suoraan tai epsuorasti. Monet matematiikassa kytetyt rekursiokaavat
voi toteuttaa rekursiivisilla proseduureilla. Toisaalta rekursio on usein kytnnss hitaampaa kuin yksinkertaiseen toistoon perustuva ohjelmakoodi.
Fortran 95:ss ovat rekursiiviset proseduurit sallittuja, toisin kuin FORTRAN 77:ss. Rekursiivisten funktioiden ja aliohjelmien otsikkorivill tytyy
kytt mrett RECURSIVE.
Esimerkiksi kertoma n! = n (n 1) 2 1 voidaan mritell rekursiivisesti:
n! = n (n 1)!, jos n > 0,

n! = 1,
jos n = 0.
(Mrittelemme kertomafunktion tss vain positiivisille kokonaisluvuille.)
Kertoma voidaan laskea kytten rekursiivista funktiota kert:
RECURSIVE FUNCTION kert(n) RESULT(kert_arvo)
IMPLICIT NONE
INTEGER, INTENT(IN) :: n
INTEGER :: kert_arvo
IF (n == 0) THEN
kert_arvo = 1
ELSE
kert_arvo = n * kert(n-1)
END IF
END FUNCTION kert
Funktion otsikkorivill on kytettv mrett RECURSIVE. Lisksi otsikkorivill on annettava RESULT-mrittely, jotta voimme kytt rekursiivisen
funktion tunnusta funktion sisll tekemn rekursiivisen funktiokutsun.
Kytmme funktion kert sisll rekursiivista kertomafunktion mritelm.
Jos muodollisen argumentin n arvo on nolla, saa funktio arvon 1. Muussa
tapauksessa kertomafunktion arvo on
kert_arvo = n * kert(n-1)
Tss kutsumme funktiota kert uudestaan, ja argumenttina on luku n-1.

Ehtoa n == 0 sanotaan rekursion lopetusehdoksi. Kaikissa rekursiivisissa ohjelmissa tytyy olla jokin lopetusehto, sill rekursio ei muuten pyshdy koskaan.
Voimme kytt edell mritelty funktiota kert seuraavasti:
112
Fortran 95/2003
PROGRAM kertoma
IMPLICIT NONE
INTEGER :: n
DO
WRITE (*,(A),ADVANCE=no) Anna n:
READ (*,*) n
WRITE (*,*) n = , n
IF (n < 0) EXIT
WRITE (*,*) n! = , kert(n)
END DO
CONTAINS
Edell esitetty funktion kert mrittely
END PROGRAM kertoma
Ohjelma toimii seuraavasti:

Anna n: 7
n =
7
n! =
5040
Anna n: 10
n =
10
n! =
3628800
Anna n: -1
n =
-1
Pohjelmassa tarkistetaan, ett luku n on suurempi tai yhtsuuri kuin nolla

ennen kertoman laskemista. Tarkistuksen voisi tietysti sijoittaa mys kertfunktion sislle. Huomaa, ett ohjelma tuottaa kokonaislukujen ylivuodon,
jos sytetty luku n on liian iso. Yleens kokonaisylivuoto tapahtuu ilman
ajonaikaista ilmoitusta, joten virhetilanteen tarkistus j ohjelmoijan vastuulle.
Voimme mritell rekursiivisen funktion otsikkolauseessa mys funktion
tyypin. Seuraavassa on esimerkki edell kytetyn funktion kert vaihtoehtoisesta mrittelyst:
RECURSIVE INTEGER FUNCTION kert(n) RESULT(kert_arvo)
IMPLICIT NONE
...
END FUNCTION kert
Otsikkolause voisi olla mys muotoa

INTEGER RECURSIVE FUNCTION kert(n) RESULT(kert_arvo)
Siis funktion paluuarvon tyyppimre voi olla RECURSIVE-mritteen edess

tai perss.
Huomaa, ett voimme laskea kertoman arvon rekursion sijaan nopeammin
kytten DO-rakennetta:
kertoma = 1
DO i = 2, n
kertoma = i*kertoma
END DO
Mys aliohjelma voi olla rekursiivinen, jolloin otsikkorivi nytt tlt:
113
RECURSIVE SUBROUTINE tunnus[([argumentti][, argumentti]...])]
Laajempia ja realistisempia esimerkkej rekursion kytst lytyy luvusta 14 sivulta 234 alkaen.
8.13
Proseduurit argumentteina
Fortranin proseduureihin voi vlitt datan lisksi argumentteina mys toisia proseduureja. Seuraavassa mritelty funktio asteina muuttaa mink
tahansa funktion palauttaman arvon radiaaneista asteiksi. Kytmme esimerkkin Fortranin standardifunktioita ASIN, ACOS ja ATAN:
PROGRAM astesti
IMPLICIT NONE
INTRINSIC ASIN, ACOS, ATAN
WRITE (*,*) arcsin(0.5): , asteina(ASIN,0.5)
WRITE (*,*) arccos(0.5): , asteina(ACOS,0.5)
WRITE (*,*) arctan(1.0): , asteina(ATAN,1.0)
CONTAINS
REAL FUNCTION asteina(f, x)
IMPLICIT NONE
REAL, EXTERNAL :: f
INTRINSIC ATAN
asteina = 45*f(x)/ATAN(1.0)
END FUNCTION asteina
END PROGRAM astesti

arcsin(0.5):
arccos(0.5):
arctan(1.0):
30.00000
60.00000
45.00000
Funktion asteina mrittelyss esiteltiin muodollinen argumentti f kytten mrett EXTERNAL:

REAL, EXTERNAL :: f
Tm kertoo kntjlle, ett muodollista argumenttia f vastaa todellisena

argumenttina reaaliarvoinen funktio.
Mys aliohjelmien vlittminen argumentteina on mahdollista. Kun todellinen argumentti on aliohjelma, on muodollinen argumentti esiteltv lauseessa EXTERNAL, koska aliohjelma ei palauta arvoa.
Seuraavassa on esimerkki aliohjelmasta, joka tekee annetun operaation pareittain kaikille argumenttitaulukkojen alkioille. Mre DIMENSION(:) tarkoittaa, ett kyseinen muodollinen argumentti on yksiulotteinen taulukko ja
vastaava todellinen argumentti voi olla vaihtelevan kokoinen. Funktio SIZE
palauttaa taulukon alkioiden lukumrn. Taulukoista kerrotaan lis luvussa 11 (sivu 164).
114
Fortran 95/2003
SUBROUTINE suorita(operaatio, t1, t2)

IMPLICIT NONE
EXTERNAL operaatio
REAL, DIMENSION(:), INTENT(INOUT) :: t1, t2
INTEGER :: i
IF (SIZE(t1) /= SIZE(t2)) THEN
STOP t1 ja t2 erisuuret!
END IF
DO i = 1, SIZE(t1)
CALL operaatio(t1(i),t2(i))
END DO
END SUBROUTINE suorita
Operaationa voisi olla kappaleessa 8.11.1 (sivu 108) mritelty aliohjelma

vaihda. Koska aliohjelman suorita todellinen argumentti ei saa olla sisinen aliohjelma, tytyy aliohjelma vaihda mritell joko moduulissa tai
ulkoisena aliohjelmana, kuten seuraavassa:
PROGRAM argumentti
IMPLICIT NONE
REAL, DIMENSION(5) :: t1, t2
EXTERNAL vaihda
t1 = -1
t1(2) = 3
t2 = 2
CALL suorita(vaihda, t1, t2)
WRITE (*,*) t1
WRITE (*,*) t2
CONTAINS
Aliohjelman suorita edell esitelty mrittely
END PROGRAM argumentti
Sijoituslauseessa t1 = -1 sijoitetaan taulukon kaikkien alkioiden arvoksi

luku -1.
Aliohjelma vaihda tytyy knt erikseen ja linkitt pohjelman kanssa.
2.0000000
-1.0000000
2.0000000
3.0000000
2.0000000
-1.0000000
2.0000000
-1.0000000
2.0000000
-1.0000000
Siis vaihto-operaatio tehtiin kaikille taulukkojen t1 ja t2 alkioille.

Ohjelmayksikn sisisi proseduureja ei saa antaa todellisiksi argumenteiksi.
Tm rajoitus on tehty tehokkuussyist: kntj voi tarvittaessa korvata
sisisten proseduurien kutsut niiden koodilla (inlining). Tm est sisisen
proseduurin kytn todellisena argumenttina.
Toinen rajoitus on, ett Fortranin standardialiohjelmia ei saa kytt todellisina argumentteina. Standardialiohjelman kutsun tosin voi sijoittaa itse
ohjelmoituun aliohjelmaan, jonka voi vlitt proseduurin todellisena argumenttina. Standardifunktioiden kyttminen todellisina argumentteina on
sallittua, kuten nimme tmn kappaleen alussa. Fortran 95:ss on kuusi
standardialiohjelmaa. Standardifunktioita on 109.
8.14
115
PURE-mre
Proseduurien mre PURE mahdollistaa sivuvaikutuksettomien proseduurien

mrittelyn. Tllaisia proseduureja voi kytt helpommin rinnakkaislaskennassa, koska niiss ei ole sivuvaikutuksia. Esimerkkin tst on silmukka:
DO i = 1, n
a(i) = laske(i)
END DO
Jos funktio laske on mritelty sivuvaikutuksettomaksi funktioksi PUREmreell, voi kntj laskea silmukan funktiokutsut rinnakkain. PUREmre helpottaa kntjn toimintaa mys ohjelmakoodia optimoitaessa,
joten sen kytt on suositeltavaa.
Mys mrittelylausekkeissa (specication expression) saa kytt puhtaita
(PURE) funktioita:
SUBROUTINE s(a)
IMPLICIT NONE
REAL, DIMENSION(:,:) :: a
REAL, DIMENSION(rivit(a),sarakkeet(a)) :: apu
...
CONTAINS
PURE FUNCTION rivit(x)
REAL, INTENT(IN) :: x(:,:)
INTEGER :: rivit
rivit = SIZE(x,DIM=1)
END FUNCTION rivit
PURE FUNCTION sarakkeet(x)
...
END FUNCTION sarakkeet
END SUBROUTINE s
Edell mriteltiin puhtaat funktiot rivit ja sarakkeet, joiden avulla voimme mritell taulukon apu koon mrittelylauseessa.
8.15
ELEMENTAL-mre
Mre ELEMENTAL mahdollistaa alkioittaisten proseduurien mrittelyn. Tllin proseduurin argumenttina voi olla skalaari tai taulukko, ja kntj huolehtii tarvittavan koodin generoimisesta.
ELEMENTAL FUNCTION f(x, y)
IMPLICIT NONE
REAL, INTENT(IN) :: x, y
REAL :: f
f = SQRT(x**2 + y**2)
END FUNCTION f
116
Fortran 95/2003
ELEMENTAL-mreell varustettua proseduuria voi kutsua kaiken muotoisilla

taulukkoargumenteilla:
REAL :: s
REAL, DIMENSION(n,n) :: a, b, c
REAL, DIMENSION(n) :: u, v, t
...
s = f(1.0, 2.0)
c = f(a, b)
t = f(u, v)
8.16
Kutsumuodon mrittely
Proseduurin tai operaattorin kutsumuodolla (interface) tarkoitetaan argumenttien lukumr ja tyyppi sek mahdollisesti palautettavan arvon tyyppi.
Tunnettu kutsumuoto (explicit interface) on kyseess silloin, kun kntj
pystyy knnsaikana selvittmn kutsumuodon sek tekemn thn liittyvi tarkistuksia. Ohjelmayksikn sisisill proseduureilla sek moduulin
proseduureilla on tunnettu kutsumuoto. Moduulien kytst kerrotaan tarkemmin luvussa 9 (sivu 126).
Oletusarvoinen kutsumuoto (implicit interface) on kyseess silloin, kun kntj ei kykene selvittmn olion kutsumuotoa. Ulkoisilla proseduureilla on
oletusarvoinen kutsumuoto.
Jos kutsumuoto ei ole automaattisesti tunnettu, voidaan se mritell ohjelmayksikn INTERFACE-lohkossa. Tm mahdollistaa esimerkiksi argumenttilistojen tarkistuksen kytettess ulkoisia proseduureja.
Voisimme muuttaa edell mritelty aliohjelmaa suorita siten, ett mrittelemme operaatio-argumentin kutsumuodon INTERFACE-lohkossa:
SUBROUTINE suorita(operaatio, t1, t2)
IMPLICIT NONE
INTERFACE
SUBROUTINE operaatio(a,b)
IMPLICIT NONE
END SUBROUTINE operaatio
END INTERFACE
REAL, DIMENSION(:), INTENT(INOUT) :: t1, t2
INTEGER :: i
IF (SIZE(t1) /= SIZE(t2)) STOP t1 ja t2 erisuuret!
DO i = 1, SIZE(t1)
END DO
END SUBROUTINE suorita
Tmn jlkeen kntj huomaisi esimerkiksi seuraavan virheellisen mrittelyn muodollisille argumenteille t1 ja t2:
117
REAL, DIMENSION(:), INTENT(IN) :: t1, t2
Lydtk virheen? Aliohjelman operaatio argumentit a ja b ovat kirjoittamamme INTERFACE-lohkon mukaan tyyppi
Tllin aliohjelmakutsu
voisi muuttaa taulukoiden t1 ja t2 alkioita, mik taas on kielletty niden

argumenttien INTENT(IN)-mrittelyll.
Kutsumuodon mrittelylohkoa (INTERFACE) voi kytt mys geneeristen
proseduurien mrittelyyn. Tllin samaa proseduurikutsua voi kytt eri
tyyppisille argumenteille. Aiheesta kerrotaan enemmn moduulien yhteydess sivulla 140.
8.17
Esimerkki: NAG-aliohjelmakirjaston kytt
Seuraavassa on esimerkki NAG-aliohjelmakirjaston aliohjelman g05faf kutsumuodon esittmisest INTERFACE-lohkossa. Tm aliohjelma tuottaa tasajakautuneita satunnaislukuja vlilt [a, b].
PROGRAM nagrnd
IMPLICIT NONE
INTERFACE
SUBROUTINE g05faf(a, b, n, x)
IMPLICIT NONE
REAL(KIND=tarkkuus), INTENT(IN) :: a
REAL(KIND=tarkkuus), INTENT(IN) :: b
REAL(KIND=tarkkuus), INTENT(OUT), DIMENSION(n) :: x
END SUBROUTINE g05faf
END INTERFACE
REAL(KIND=tarkkuus), DIMENSION(5) :: taulukko
CALL g05faf(-1.0_tarkkuus, 1.0_tarkkuus, &
SIZE(taulukko), taulukko)
WRITE (*,*) taulukko
END PROGRAM nagrnd

-0.6274038453462165 -0.7423877855038070 -0.2103735021112449
-0.8656148369960344 0.3577838993895552
Tss kytettiin NAG-aliohjelmakirjaston vanhempaa FORTRAN 77 -pohjaista versiota. Saatavilla on mys Fortran 95:een perustuva aliohjelmakirjasto, joka kytt hyvkseen moduuleita ja muita Fortranin kehittyneit
piirteit.
118
Fortran 95/2003
8.18
Valinnaiset ja avainsana-argumentit
Toisinaan on hyv, jos proseduurin kutsussa voi antaa vain osan argumenteista ja kytt oletusarvoja lopuille. Tllaisia argumentteja kutsutaan valinnaisiksi (optional). Useissa Fortranin standardiproseduureissa voi kytt
valinnaisia argumentteja. Seuraavassa on esimerkki tst:
Tss jtettiin antamatta eksponentin vaihteluvli lajiparametrin mrittelyss, jolloin funktio SELECTED_REAL_KIND kytt oletusarvoa tlle argumentille.
Avainsana-argumenteilla tarkoitetaan proseduurin argumentin ilmaisemista muodossa avainsana = arvo. Jos kytetn avainsana-argumentteja, on
argumenttien jrjestys vapaa, koska avainsana ilmaisee, mit muodollista
argumenttia kyseinen todellinen argumentti vastaa.
Seuraavassa on esimerkki avainsana-argumenttien kytst:
tarkkuus = SELECTED_REAL_KIND(r = 30, p = 6)
Tss annettiin funktiokutsun argumentit p ja r vaihtoehtoisessa jrjestyksess kytten avainsana-argumentteja.

Valinnaisia ja avainsana-argumentteja voi kytt samassa proseduurin kutsussa:
INTEGER, PARAMETER :: tarkkuus = SELECTED_REAL_KIND(r = 100)
Tss otamme kyttn reaalilukulajin, jonka eksponentin vaihteluvli on

vhintn 100. Argumentti p jtetn antamatta.
Jotta valinnaisia ja avainsana-argumentteja voisi kytt, on proseduurin
kutsumuodon oltava tunnettu. Standardiproseduurien kutsumuoto on automaattisesti tunnettu. Fortranin standardiproseduurien kutsumuodot ja
avainsanat on esitetty luvussa 13 (sivu 215).
8.19
Esimerkki: keskiarvon laskeminen
Olkoon tehtvn laskea reaalilukutaulukon lukujen keskiarvo. Tmn voi

tehd funktiolla keskiarvo:
PROGRAM keskiarvo_testi
IMPLICIT NONE
REAL, DIMENSION(6) :: x
x = (/ 1.0, -1.0, 0.5, 1.5, 2.5, 5.0 /)
WRITE (*,*) keskiarvo: , keskiarvo(x)
CONTAINS
REAL FUNCTION keskiarvo(x)
IMPLICIT NONE
REAL, DIMENSION(:), INTENT(IN) :: x
119
keskiarvo = SUM(x)/SIZE(x)
END FUNCTION keskiarvo
END PROGRAM keskiarvo_testi
Haluaisimme muuttaa funktiota keskiarvo siten, ett keskiarvon laskemisesta voidaan jtt pois liian pienet tai liian suuret luvut. Valinnaiset argumentit mahdollistavat sen, ett samalla funktiolla voi laskea sek tavallisen
keskiarvon ett edell kuvatun muunnelman. Kytnnss tm tapahtuu
antamalla muodollisille argumenteille mre OPTIONAL. Funktiolla PRESENT
voi tarkistaa, onko valinnainen argumentti annettu funktiokutsussa.
Seuraavassa on muutetun funktion mrittely:
REAL FUNCTION keskiarvo(x, alaraja, ylaraja)
IMPLICIT NONE
REAL, DIMENSION(:), INTENT(IN) :: x
REAL, INTENT(IN), OPTIONAL :: alaraja, ylaraja
REAL :: a, b
INTEGER :: i, lkm
a = -HUGE(a)
b = HUGE(b)
IF (PRESENT(alaraja)) a = alaraja
IF (PRESENT(ylaraja)) b = ylaraja
keskiarvo = 0
lkm = 0
DO i = 1, SIZE(x)
IF (x(i) >= a .AND. x(i) <= b) THEN
keskiarvo = keskiarvo + x(i)
lkm = lkm + 1
END IF
END DO
IF (lkm /= 0) THEN
keskiarvo = keskiarvo/lkm
ELSE
keskiarvo = -HUGE(keskiarvo)
END IF
END FUNCTION keskiarvo
Funktiossa kytetn paikallisia muuttujia a ja b ala- ja ylrajojen tallentamiseen. Alussa rajoiksi asetetaan suurimmat negatiiviset ja positiiviset luvut
kyttmll funktiota HUGE. Jos valinnaiset argumentit on annettu, kytetn
rajoina annettuja arvoja:
IF (PRESENT(alaraja)) a = alaraja
IF (PRESENT(ylaraja)) b = ylaraja
Keskiarvo lasketaan muuttujaan keskiarvo DO-silmukassa. Silmukassa tarkistetaan, kuuluuko arvo x(i) halutulle vlille. Arvo x(i) listn muuttujaan keskiarvo vain tss tapauksessa:
IF (x(i) >= a .AND. x(i) <= b) THEN
keskiarvo = keskiarvo + x(i)
lkm = lkm + 1
END IF
Funktion lopussa palautetaan joko laskettu keskiarvo tai itseisarvoltaan suurin muuttujalla keskiarvo esitettviss oleva negatiivinen luku, jos yhtn
120
Fortran 95/2003
lukua ei kuulunut haluttuun vliin:

IF (lkm /= 0) THEN
keskiarvo = keskiarvo/lkm
ELSE
keskiarvo = -HUGE(keskiarvo)
END IF
Seuraavassa ohjelmassa testaamme edell mritelty funktiota:

PROGRAM keskiarvo_testi
IMPLICIT NONE
REAL, DIMENSION(6) :: a
a = (/ 1.0, -1.0, 0.5, 1.5, 2.5, 5.0 /)
write (*,(A,6(F7.3))) a: , a
WRITE (*,(A,F7.3)) keskiarvo: , keskiarvo(a)
WRITE (*,(A,F7.3)) keskiarvo: , keskiarvo(a,0.0)
WRITE (*,(A,F7.3)) keskiarvo: , &
keskiarvo(ylaraja=3.0,alaraja=-2.0,x=a)
WRITE (*,(A,F7.3)) keskiarvo: , keskiarvo(a,1.0,0.0)
CONTAINS
Funktion keskiarvo edell esitelty mrittely
END PROGRAM keskiarvo_testi
Ensimmisess funktiokutsussa jtmme valinnaiset argumentit antamatta.

Toisessa annamme ensimmisen valinnaisen argumentin eli alarajan:
keskiarvo(a,0.0)
Kolmannessa funktiokutsussa kytmme avainsana-argumentteja ja annamme molemmat valinnaiset argumentit:

keskiarvo(ylaraja=3.0,alaraja=-2.0,x=a)
Viimeisess funktiokutsussa annamme (virheellisesti) ylrajaa suuremman

alarajan (tm tilanne olisi ehk hyv tarkistaa funktiossa).
Ohjelman tulostus voisi olla seuraavaa:
a:
1.000 -1.000 0.500
keskiarvo:
1.583
keskiarvo:
2.100
keskiarvo:
0.900
keskiarvo: *******
1.500
2.500
5.000
Viimeinen funktiokutsu palautti vastauksena itseisarvoltaan suuren negatiivisen luvun, joka ei mahtunut annettuun tulostuskenttn.
Avainsana-argumentteja voi kytt aina, kun proseduurin kutsumuoto on
tunnettu. Valinnaisten argumenttien tapauksessa argumenttilistan keskelt
voi jtt pois argumentteja, jolloin loppuosalle argumenteista on kytettv
avainsanoja.
121
8.20 Milloin tarvitsemme kutsumuodon

mrittely
Jos haluamme antaa ulkoiselle proseduurille valinnaisen tai avainsana-argumentin, on proseduurin kutsumuoto mriteltv INTERFACE-lohkossa.
Mys vaihtelevan pituisen merkkijonon, taulukon tai osoitintyypin palauttava ulkoinen proseduuri on mriteltv INTERFACE-lohkossa tai kutsumuodon on oltava muuten tunnettu. Taulukkoja ja osoitintyyppej ksitelln
luvussa 11 (sivu 164).
Kutsumuodon mrittelylohkoa tarvitaan mys, jos ulkoisella proseduurilla
on oletetun kokoinen taulukkoargumentti tai sen argumenttitaulukolla on
mre POINTER tai TARGET. Mys kytettess ulkoista proseduuria muodollisena tai todellisena argumenttina on kutsumuoto syyt mritell.
Lisksi proseduurin kutsumuoto on mriteltv INTERFACE-lohkossa, jos
moduulin proseduuria tai ulkoista proseduuria kytetn operaattorin tai
sijoituslauseen mrittelemiseen. Mys geneerisen nimen mrittelyyn tarvitaan kutsumuodon mrittelylohko. Tst kerrotaan kappaleessa 9.12 (sivu 140).
8.21
Nkyvyysalueet
Nkyvyysalue (scope) tarkoittaa sit ohjelman lauseiden kokonaisuutta, jossa kukin muuttujan, vakion tms. tunnus tai lausenumero on nkyviss. Kunkin ohjelmayksikn voi katsoa koostuvan joukosta nkyvyysalueita, jotka
eivt mene toistensa kanssa pllekkin.
Nkyvyysalue voi olla jokin seuraavista:
rakenteisen tyypin mrittely
proseduurin kutsumuodon mrittelylohko (interface body) lukuunottamatta kyseisen lohkon sisll olevia rakenteisten tyyppien mrittelyj, kutsumuodon mrittelylohkoja tai proseduureja
ohjelmayksikk (moduuli, pohjelma tai proseduuri) lukuunottamatta
kyseisen ohjelmayksikn sisll olevia rakenteisten tyyppien mrittelyj, kutsumuodon mrittelylohkoja tai proseduureja.
Taulukossa 8.1 on havainnollistettu nkyvyysalueita. Mrittelemme pohjelmassa rakenteisen tyypin kurssilainen, jota kytmme mys aliohjelmassa lue_tiedot. Mrittelemme lisksi funktion apurutiini kutsumuodon INTERFACE-lohkossa.
Pohjelmassa voitaisiin kytt tunnusta nimi vaikkapa muuttujan nimen, vaikka sama tunnus esiintyy tyypin kurssilainen mrittelyss. Tm
122
Fortran 95/2003
Taulukko 8.1: Esimerkki ohjelman sisltmist nkyvyysalueista.
PROGRAM oppi
IMPLICIT NONE
TYPE kurssilainen
REAL :: arvosana
END TYPE kurssilainen
TYPE(kurssilainen), DIMENSION(lkm) :: &
oppilaat
INTEGER :: luokan_koko
CALL lue_tiedot(luokan_koko, oppilaat)
CONTAINS
SUBROUTINE lue_tiedot(koko, taulukko)
INTEGER, INTENT(OUT) :: koko
TYPE(kurssilainen), DIMENSION(:), &
INTENT(OUT) :: taulukko
INTERFACE
FUNCTION apurutiini(lkm)
IMPLICIT NONE
REAL, INTENT(IN) :: lkm
jne.
END FUNCTION apurutiini
END INTERFACE
jne.
END SUBROUTINE lue_tiedot
END PROGRAM oppi
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
alue
1
1
2
2
2
2
1
1
1
1
1
1
3
3
3
3
4
5
5
5
5
5
4
3
3
1
johtuu siit, ett tyypinmrittelyn sisll olevat tunnukset eivt kuulu pohjelman nkyvyysalueeseen eivtk siten mene pllekkin pohjelman
tunnusten kanssa.
Vastaavasti INTERFACE-lohkon sisll voi kytt vapaasti tunnuksia, kunhan ne ovat yksiksitteiset kunkin kutsumuodon mrittelylohkon sisll.
Esimerkiksi funktion apurutiini muodollinen argumentti lkm ei sekoitu
pohjelman saman nimiseen nimettyyn vakioon.
Kun tunnus on mritelty jossakin nkyvyysalueessa, se on kytettviss
kaikkialla nkyvyysalueessa. Jos nkyvyysalueessa otetaan kyttn moduuli USE-lauseella (tst kerrotaan seuraavassa luvussa), ovat kyseisess moduulissa mritellyt tunnukset kytettviss tmn nkyvyysalueen sisll.
Tllin nkyvyysalueessa ei en voi mritell saman nimisi paikallisia
tunnuksia.
Kussakin nkyvyysalueessa voi kytt sek nkyvyysalueen sisll mriteltyj tunnuksia ett sen isnnn nkyvyysalueessa mriteltyj tunnuksia.
Paikallinen tunnus korvaa aina isnnss mritellyn saman nimisen tunnuksen.
123
Sisinen proseduuri voi viitata isnnn nkyvyysalueessa mriteltyihin tunnuksiin, jos proseduurissa ei ole mritelty saman nimist paikallista tunnusta. Taulukon 8.1 esimerkiss on pohjelman nimetty vakio lkm kytettviss aliohjelmassa lue_tiedot, jos aliohjelmassa ei mritell saman
nimist tunnusta.
Myskn INTERFACE-lohkon sisiset mrittelyt eivt vaikuta sisisen funktion lue_tiedot nkyvyysalueessa. Huomaa, ett INTERFACE-lohkon sislle
eivt ny lohkon isnnss tehdyt mrittelyt. Siten apurutiini-funktion
kutsumuodon mrittelyss (nkyvyysalue 5) ei ole kytettviss nkyvyysalueissa 1, 2 tai 3 tehtyj mrittelyj.
8.22
Yhteenveto
Fortranin proseduurit (aliohjelmat ja funktiot) voi jakaa kolmeen tyyppiin:

ohjelmayksikn sisiset proseduurit, ulkoiset proseduurit sek moduulin
proseduurit. Koska sisisten ja moduulin proseduurien kutsumuoto on tunnettu, pystyy kntj tekemn kutsumuodon virheentarkistukset ohjelman knnsaikana. Tst syyst ei ulkoisia proseduureja kannata kytt,
ellei muuta mahdollisuutta ole. Kyttmll INTERFACE-lohkoa voidaan kuitenkin mys ulkoisen proseduurin kutsumuoto tehd tunnetuksi.
Funktio mritelln seuraavasti:
[tyyppi] [RECURSIVE] [tyyppi] FUNCTION tunnus([argumentti] &
[, argumentti]...) [RESULT(tunnus)]
[mrittelylauseet]
[suoritettavat_lauseet]
[CONTAINS
sisinen_proseduuri
[sisinen_proseduuri]...]
END [FUNCTION [tunnus]]
Aliohjelma mritelln vastaavasti:

[RECURSIVE] SUBROUTINE tunnus[([argumentti][,argumentti]...])]
[mrittelylauseet]
[CONTAINS
sisinen_proseduuri
END [SUBROUTINE [tunnus]]
Aliohjelmaa kutsutaan CALL-lauseessa:

CALL aliohjelma[(argumentti[, argumentti]...)]
CALL aliohjelma[([nimi=]argumentti[, [nimi=]argumentti]...)]
Jlkimmisess tapauksessa kytetn avainsana-argumentteja.
124
Fortran 95/2003
Harjoitustehtvi
1. Muuta kappaleen 8.8 esimerkkiohjelmaa siten, ett se muuttaa mys
skandinaaviset merkit , ja isoiksi kirjaimiksi.
2. Kirjoita funktio, joka laskee standardifunktioiden SIN, COS ja TAN arvon, kun reaalilukuargumentti annetaan asteina eik radiaaneina. Katso
mallia kappaleesta 8.13 sivulla 113.
3. Kirjoita kertoman laskeva rekursiivinen aliohjelma (ei funktio!), jonka
kutsusyntaksi voisi olla
CALL kertoma(n,tulos)
Kirjoita mys DO-silmukkaversio kertoman laskemiseksi. Vertaile rekursiivisen funktion ja silmukkaversion nopeutta. Voit kytt vertailuun
Unixin time-komentoa, Fortran 90:n standardialiohjelmaa SYSTEM_CLOCK
tai Fortran 95:n aliohjelmaa CPU_TIME.
4. Kirjoita funktio, joka laskee n termi sinifunktion sarjakehitelmst
pisteess x. Sinifunktion sarjakehitelm origon ympristss on
sin x = x
x 2i1
x3
x5
x7
(1)i+1
+
+ =
.
6
120
5040
(2i 1)!
i=1
Huomaa, ett tt sarjakehitelm voi kytt vain, kun |x| 0. Laske likiarvo lausekkeelle sin 0.5 kyttmll 2 tai 4 termi. Laske mys
lausekkeen SIN(0.5) arvo.
Huomaa, ett sarjakehitelmn n:s termi tn toteuttaa yhtln
t1 = x,
tn+1 = tn
x2
.
2n(2n + 1)
Kirjoita funktiosta rekursiivinen versio.

5. Kirjoita rekursiivinen funktio kahden kokonaisluvun suurimman yhteisen tekijn laskemiseksi. Kyt hyvksi identiteettej
syt(m, n) = syt(n, MOD(m, n)),

syt(m, 0) = m.
Vertaile rekursiivisen funktion ja kappaleessa 7.5 sivulla 93 esitetyn
silmukkaversion nopeutta. Voit kytt vertailuun Unixin time-komentoa, Fortran 90:n aliohjelmaa SYSTEM_CLOCK tai Fortran 95:n aliohjelmaa CPU_TIME.
6. Kirjoita aliohjelma kokonaisluvuista a ja b koostuvan murtoluvun a/b
sieventmiseksi. Kyt apuna edellisess harjoituksessa tekemsi suurimman yhteisen tekijn laskevaa funktiota.
125
7. Kirjoita rekursiivinen funktio joka laskee Tribonaccin lukuja:
x = 1, x = 1, x = 1,
1
2
3
xn = xn1 + xn2 + xn3 , n > 3.
Laske x12 . Tutki laskenta-ajan kyttytymist n:n funktiona kyttmll Unixin time-komentoa, Fortran 90:n aliohjelmaa SYSTEM_CLOCK tai
Fortran 95:n aliohjelmaa CPU_TIME. Onko rekursiivinen funktio tehokas? Toteuta laskeminen mys silmukkarakenteen avulla.
8. Kirjoita rekursiivinen funktio positiivisen kokonaisluvun m muuntamiseksi kymmenjrjestelmst k-kantaiseen jrjestelmn (1 < k < 100).
Esimerkiksi luku 1996 on 8-jrjestelmss (3714)8 = 3 83 + 7 82 +
81 + 4. Kyt ohjelmassasi hyvksi identiteetti
m = (dn kn1 + dn1 kn2 + + d1 )k + d0
= (m/k) k + MOD(m, k).
Edell merkint m/k tarkoittaa kokonaislukujen jakolaskua.
Kirjoita mys silmukkaversio algoritmista. Vertaile rekursiivisen funktion ja silmukkaversion nopeutta. Voit kytt vertailuun Unixin timekomentoa, Fortran 90:n aliohjelmaa SYSTEM_CLOCK tai Fortran 95:n aliohjelmaa CPU_TIME.
9. Kirjoita proseduuri skalaarifunktion f (x) integroimista varten. Kyt
esimerkiksi Gaussin integroimiskaavaa
I

ba
a+b
a+b
ba
ba
f(
) + f(
+ ) ,
2
2
2
2 3
2 3
miss integroimisvli on [a, b]. Kyt valinnaisia argumentteja seuraavasti:

jos vasenta integroimisrajaa a ei ole annettu, asetetaan rajan arvoksi a = 0,
jos oikeaa integroimisrajaa b ei ole annettu, asetetaan rajan arvoksi
b = a + 1.
10. Muuta kappaleen 8.11.2 (sivu 110) pohjelmaa ulkolainen siten, ett
ulkoisen funktion desimaalit kutsumuoto esitelln ohjelman alussa
INTERFACE-lohkossa.
126
Fortran 95/2003
Moduulit ja operaattorit
Moduulit mahdollistavat tietorakenteiden ja niit ksittelevien algoritmien

sijoittamisen samaan ohjelmayksikkn. Lisksi toteutuksen yksityiskohdat voidaan piilottaa moduulin kyttjlt. Tllin vltytn tarpeettomilta
ja mahdollisesti yllttvilt riippuvuuksilta ohjelmayksikiden vlill. Esittelemme tss luvussa mys operaattorien mrittely moduulien avulla.
9.1
Modulaarinen ohjelmointi
Modulaarisuudella tarkoitetaan ohjelmointitehtvn jakamista toisistaan

minimaalisesti riippuviin osiin eli moduuleihin. Moduulissa voidaan mritell mm. nimettyj vakioita, muuttujia, rakenteisia tyyppej ja proseduureja. Kunkin moduulin sisinen toteutus voidaan piilottaa kyseist moduulia
kyttvilt ohjelmayksikilt. Ainoastaan moduulin kyttliittym on julkinen.
Fortranin moduuliin voi sijoittaa ohjelmiston eri ohjelmayksikiden tarvitsemia globaaleja vakioita ja muuttujia. Moduulissa voi mys mritell uusia
tietotyyppej ja niihin liittyvi operaatioita. Moduulissa mriteltyj tietoolioita (muuttujat, vakiot, proseduurit jne.) voi kytt useammassa kuin
yhdess ohjelma-yksikss.
Olkoon kuvitteellisena esimerkkin datan lajitteluun tarkoitettu moduuli.
Moduulissa mritellyt tunnukset voidaan mritell yksityisiksi, jolloin ne
ovat kytettviss vain moduulin sislt ksin. Julkisiksi voimme mritell
moduulin ja lajittelurutiinin nimi sek lajittelurutiinin kutsusyntaksi. Toteutuksen yksityiskohdat voimme jtt ohjelmoijan vapaasti valittaviksi.
Lajittelumoduulissa voidaan alussa kytt yksinkertaista ja helposti toteutettavaa lajitteluproseduuria. Datamrn kasvaessa voidaan moduulin sisinen toteutus uusia tehokkaammaksi.
Moduuleilla voimme toteuttaa abstrakteja tietorakenteita, jolloin kyttj
nkee tietorakenteelle mritellyt operaatiot mutta ei pse vaikuttamaan
tietorakenteen sisiseen toteutukseen. Tllin on mahdollista hajauttaa ohjelmankehitys pieniin erillisiin osatehtviin, joissa ohjelmoijat voivat halutessaan muuttaa toteutuksen yksityiskohtia ohjelmiston toiminnallisuuden
muuttumatta. Lisksi abstrakteja tietorakenteita on helpompi yllpit ja
9. Moduulit ja operaattorit
127
kehitt, koska toteutuksessa ei ole sitouduttu tiettyyn sisiseen datan esitystapaan.

Moduulien avulla voi mys korvata vanhoissa Fortran-ohjelmissa kytetyt
COMMON-alueet ja BLOCK DATA -ohjelmayksikt.
9.2 Ohjelmayksikkjen vliset suhteet

Kuva 9.1 havainnollistaa Fortranin eri ohjelmayksikkjen suhdetta toisiinsa.
pohjelma
moduuli
CONTAINS
CONTAINS
CONTAINS
ulkoinen proseduuri
CONTAINS
CONTAINS
moduulin
proseduuri
sisinen
proseduuri
Kuva 9.1: Fortran 95:n ohjelmayksikiden liittyminen toisiinsa.
Jokaisessa ohjelmassa tulee olla tsmlleen yksi pohjelma. Pohjelmalla

voi olla kytssn sisisi proseduureja, jotka mritelln pohjelman lopussa CONTAINS-lauseen jlkeen. Pohjelma voi lisksi kytt hyvkseen
ulkoisia proseduureja ja moduuleja. Ulkoisilla proseduureilla ja moduulin
proseduureilla voi olla omia sisisi proseduureja, mutta sisisill proseduureilla ei en voi olla sisisi proseduureja.
Moduuleissa voi mritell mm. nimettyj vakioita, muuttujia, uusia tietotyyppej, NAMELIST-ryhmi ja proseduureja. Moduulit voivat kytt toisia
moduuleita, jolloin moduuleista muodostuu hierarkkinen rakenne.
Ulkoiset proseduurit voi ohjelmoida toisella ohjelmointikielell. Esimerkiksi C-kielisten rutiinien kyttminen Fortranista ksin ei sislly Fortranin tai
C-kielen mrittelyyn, mutta onnistuu joissakin laiteympristiss, esimerkiksi useimmissa Unix-koneissa. Ulkoiset proseduurit voivat olla tietenkin
mys Fortran-kielell kirjoitettuja, mutta tmn sijaan kannattaa yleens
kytt sisisi proseduureja tai moduulirakenteita.
128
Fortran 95/2003
9.3
Esimerkki: vakioiden mrittely
Moduulissa voi mritell vaikkapa usein kytettyj vakioita. Seuraavaan

moduuliin on sijoitettu pituusyksikkjen muunnoskertoimia sisltv vakiotaulukko matkat (perusyksikkn on metri).
MODULE yksikot
IMPLICIT NONE
REAL, DIMENSION(6), PARAMETER :: &
matkat = (/ &
0.01, &
! sentit
0.0254, &
! tuumat
0.3048, &
! jalat
0.9144, &
! jaardit
1e3, &
! kilometrit
1609.34 /)
! mailit
END MODULE yksikot
Moduulin mrittely alkaa MODULE-lauseella ja pttyy vastaavaan END MODULE

-lauseeseen.
Tm moduuli voidaan ottaa kyttn lauseella USE:
PROGRAM vakiotesti
USE yksikot
IMPLICIT NONE
WRITE (*,*) tuumat senttein: , matkat(2)/matkat(1)
END PROGRAM vakiotesti
Huomaa, ett lause USE tulee antaa ennen IMPLICIT NONE -lausetta. Jotta
pohjelmassa voidaan kytt moduulia yksikot, on se knnettv ennen
pohjelmaa. Ohjelman kntminen ja ajaminen voisi tapahtua Unix-ympristss seuraavasti:
% f90 -c yksikt.f90
% f90 -o vakiotesti vakiotesti.f90 yksikot.o
% ./vakiotesti
tuumat senttein: 2.539999962
Jos moduulia yksikot kytettisiin USE-lauseella pohjelman lisksi mys

aliohjelmassa laske, olisi ohjelmayksikiden kyttkaavio kuvan 9.2 mukainen. Siten moduuli tarjoaa helpon tavan ottaa kyttn ohjelmiston tarvitsemaa globaalia dataa.
9.4
Esimerkki: pituusyksikkjen muunnokset
Edell mritelty moduuli yksikot on melko hankala kytt, koska kyttjn tulisi muistaa, mit vakioarvoja taulukon matkat alkiot vastaavat. Moduulia voi laajentaa siten, ett se sislt ohjelman, joka tekee muunnoksen
halutusta pituusyksikst toiseen. Jatkossa esitmme mys, miten taulukko
matkat voidaan mritell kytettvksi vain moduulin sislt ksin.
129
MODULE yksikot
...
END MODULE yksikot
PROGRAM ohjelma
USE yksikot
...
CALL laske
...
END PROGRAM ohjelma
SUBROUTINE laske
USE yksikot
...
END SUBROUTINE laske
Kuva 9.2: Moduulin yksikot kytt useasta eri ohjelmayksikst. Sek pohjelma ett pohjelman kutsuma aliohjelma laske ottavat moduulin kyttn USElauseella.
Moduulin rakenne mritelln seuraavasti:

MODULE tunnus
[mrittelyt]
[CONTAINS
proseduuri
[proseduuri]...]
END MODULE tunnus
Edellisess kappaleessa emme tarvinneet CONTAINS-lauseen jlkeen tulevaa

osaa. Nyt laajennamme esimerkki lismll moduuliin funktion muunna_r,
joka tekee halutut muunnokset pituusyksikkjen vlill:
MODULE yksikot
IMPLICIT NONE
Edell esitetyt vakioiden mrittelyt
CONTAINS
RECURSIVE FUNCTION muunna_r(x, alkup, kohde) RESULT(tulos)
IMPLICIT NONE
CHARACTER(LEN=*), INTENT(IN) :: alkup, kohde
REAL :: tulos
SELECT CASE (alkup)
CASE (sentti, cm)
tulos = muunna_r(matkat(1)*x,
CASE (tuuma, in)
CASE (jalka, ft)
CASE (jaardi, yd)
CASE (kilometri, km)
metri, kohde)
metri, kohde)
metri, kohde)
metri, kohde)
metri, kohde)
130
Fortran 95/2003
CASE (maili, mile)

tulos = muunna_r(matkat(6)*x, metri, kohde)
CASE (metri, m)
SELECT CASE (kohde)
CASE (metri, m);
tulos = x
CASE (sentti, cm);
tulos = x/matkat(1)
CASE (tuuma, in);
tulos = x/matkat(2)
CASE (jalka, ft);
tulos = x/matkat(3)
CASE (jaardi, yd);
tulos = x/matkat(4)
CASE (kilometri, km); tulos = x/matkat(5)
CASE (maili, mile);
tulos = x/matkat(6)
CASE DEFAULT;
tulos = -HUGE(tulos)
END SELECT
CASE DEFAULT
tulos = -HUGE(tulos)
END SELECT
END FUNCTION muunna_r
END MODULE yksikot
Ennen CONTAINS-lausetta annetut mrittelyt ovat suoraan kytettviss

moduulin proseduureissa. Moduulin yksikot alussa mritelty vakiotaulukkoa matkat kytetn aliohjelmassa muunna_r.
Muunnosmoduuli yksikt muuntaa ensin alkuperisen yksikn metreihin
ja kutsuu tmn jlkeen itsen muuntaakseen tuloksen haluttuun yksikkn. Jos yksikkj ei tunnisteta, ohjelma palauttaa itseisarvoltaan hyvin
suuren negatiivisen luvun.
Moduulia kytetn seuraavaan tapaan:
PROGRAM muunnostesti
USE yksikot
IMPLICIT NONE
REAL :: luku
CHARACTER(LEN=10) :: yks1, yks2
WRITE (*,(A)) Anna arvo sek alkuperinen ja&
& haluttu yksikk:
READ (*, *) luku, yks1, yks2
WRITE (*,(A,G12.6)) Tulos: , muunna_r(luku,yks1,yks2)
END PROGRAM muunnostesti
Muunnamme nyt kolme tuumaa senteiksi:

Anna arvo sek alkuperinen ja haluttu yksikk:
3 tuuma cm
Tulos: 7.62000
Kytimme sytteess lainausmerkkej merkkijonojen ymprill, vaikka tss tapauksessa ne eivt ole tarpeen, sill merkkijonot tuuma ja cm eivt
sisll esimerkiksi vlilyntej.
131
9.5 Moduulin kyttminen toisista moduuleista

Seuraavassa moduulissa mrittelemme reaalilukulajin reaaliluku, joka
pystyy esittmn reaalilukuja vhintn kuuden numeron tarkkuudella:
MODULE tarkkuus
IMPLICIT NONE
INTEGER, PARAMETER :: reaaliluku = SELECTED_REAL_KIND(6)
! INTEGER, PARAMETER :: reaaliluku = SELECTED_REAL_KIND(12)
END MODULE tarkkuus
Moduulissa on kommentoitu pois kytst vaihtoehtoinen lajiparametrin

mritelm, jossa mritelln 12 numeron tarkkuus.
Muissa ohjelmayksikiss voimme ottaa kyttn halutun reaalilukujen tarkkuuden lauseella
USE tarkkuus
Mrittelemme moduulissa tarkkuus joko suuren tai pienen tarkkuuden

lajiparametrin reaaliluku. Reaalimuuttujien mrittelyt voidaan tehd tmn jlkeen seuraavaan tapaan:
USE tarkkuus
IMPLICIT NONE
REAL(KIND=reaaliluku) :: x, y, z
Jos haluamme myhemmin muuttaa kytetty laskentatarkkuutta suuremmaksi, voimme yksinkertaisesti muuttaa moduulia tarkkuus seuraavasti:
MODULE tarkkuus
IMPLICIT NONE
! INTEGER, PARAMETER :: reaaliluku = SELECTED_REAL_KIND(6)
INTEGER, PARAMETER :: reaaliluku = SELECTED_REAL_KIND(12)
END MODULE tarkkuus
Kun knnmme uudestaan tmn moduulin ja kaikki siit riippuvat moduulit, toimii koko ohjelmistomme suuremmalla tarkkuudella.
9.6 Julkisuus ja yksityisyys

Seuraavassa moduulissa kytetn edell mritelty tarkkuus-moduulia:
MODULE vakiot
USE tarkkuus
IMPLICIT NONE
REAL(KIND=reaaliluku), PRIVATE :: x
REAL(KIND=reaaliluku), PARAMETER, PUBLIC :: &
toleranssi = 100*EPSILON(x), &
maksimiarvo = HUGE(x)
END MODULE vakiot
Muuttuja x on mritelty yksityiseksi kytten mrett PRIVATE. Tllin

muuttuja x nkyy vain moduulin vakiot sisll. Vakiot toleranssi ja
132
Fortran 95/2003
maksimiarvo mriteltiin julkisiksi kyttmll mrett PUBLIC, jolloin vakioita voidaan kytt moduulin ulkopuolella USE-lauseen avulla.
Standardifunktio EPSILON palauttaa pienimmn positiivisen liukuluvun ,
jolla ptee 1 + > 1. Standardifunktio HUGE palauttaa suurimman reaaliluvun, joka on esitettviss argumenttia vastaavalla tietotyypill.
Oletuksena on, ett moduulissa mritellyt oliot ovat julkisia. Tllin ne nkyvt niiss ohjelmayksikiss, joissa moduuli otetaan kyttn USE-lauseella.
Moduulia vakiot voisi kytt seuraavasti:
PROGRAM vakiotesti
USE vakiot
IMPLICIT NONE
WRITE (*,*) toleranssi: , toleranssi
WRITE (*,*) maksimi: , maksimiarvo
END PROGRAM vakiotesti

toleranssi:
1.1920929E-05
maksimi:
3.4028235E+38
Kuvassa 9.3 on havainnollistettu pohjelman sek moduulien vakiot ja

tarkkuus hierarkkista kytt.
pohjelma vakiotesti
USE vakiot
USE tarkkuus
Kuva 9.3: Moduulien kyttkaavio.
PUBLIC- tai PRIVATE-mreen sijaan voi kytt erillisi lauseita, jotka asettavat moduulin tunnuksen julkiseksi tai yksityiseksi:
MODULE vakiot
USE tarkkuus
IMPLICIT NONE
PRIVATE
REAL(KIND=reaaliluku) :: x
REAL(KIND=reaaliluku), PARAMETER :: &
toleranssi = 100*EPSILON(x), &
maksimiarvo = HUGE(x)
PUBLIC :: toleranssi, maksimiarvo, reaaliluku
END MODULE vakiot
Jos PUBLIC- tai PRIVATE-lauseelle ei anneta argumentteja, asettaa lause oletusarvon moduulin tunnusten julkisuudelle. Edell mriteltiin tunnukset
oletusarvoisesti yksityisiksi lauseella
133
PRIVATE
Tunnukset toleranssi, maksimiarvo ja reaaliluku mriteltiin julkisiksi

lauseessa
PUBLIC :: toleranssi, maksimiarvo, reaaliluku
9.7 USE-lauseen eri kytttavat

Lauseella
USE moduuli
otetaan kyttn kaikki moduulissa mritellyt julkiset tunnukset. Jos osalle kyttn otetun moduulin tunnuksista halutaan antaa uusi nimi, tm
onnistuu seuraavasti:
USE moduuli[, paikallinen_tunnus => tunnus_moduulissa]...
Tten otettaessa kyttn edellisess kappaleessa mritelty moduuli vakiot

voidaan osalle moduulin tunnuksista antaa uudet nimet:
USE vakiot, tyyppi => reaaliluku, maksimi => maksimiarvo
IMPLICIT NONE
REAL(KIND=tyyppi) :: x = maksimi
Tss mriteltiin muuttuja x kytten moduulista vakiot perisin olevia

vakioita tyyppi ja maksimi.
Jos halutaan ottaa kyttn vain osa moduulissa mritellyista tunnuksista,
onnistuu tm kyttmll mrett ONLY:
USE moduuli, ONLY : tunnus_moduulissa[, tunnus_moduulissa]...
Mys nille tunnuksille voi antaa uudet nimet:

USE vakiot, ONLY : tyyppi => reaaliluku, &
maksimi => maksimiarvo
Saman moduulin voi ottaa kyttn useassa eri USE-lauseessa:

USE vakiot, ONLY : tyyppi => reaaliluku
USE vakiot, ONLY : maksimi => maksimiarvo
IMPLICIT NONE
REAL(KIND=tyyppi) :: x = maksimiarvo
Jos sama moduuli otetaan kyttn useaan kertaan, ksitelln kyseiset USElauseet yhten kokonaisuutena. Huomaa, ett moduulin olion voi ottaa kyttn vain yhdell nimell. Seuraava on siis kielletty:
USE vakiot, ONLY : maksimiarvo
Mrittely ONLY kannattaa kytt, sill tllin USE-lauseesta nkee suoraan, mit moduulin tunnuksia ohjelmayksikss kytetn. Lisksi tllin
on helpompi vltt koniktit moduulissa mriteltyjen tunnusten ja ohjelmayksikn omien tunnusten kesken.
134
Fortran 95/2003
Jos USE-lausetta kytetn moduulissa, voi kyttn otettujen tunnusten

julkisuuden mritell uudelleen kyttmll lausetta PUBLIC tai PRIVATE:
MODULE vakiot2
USE vakiot, ONLY : tyyppi => reaaliluku
IMPLICIT NONE
PRIVATE
PUBLIC :: tyyppi, maksimi
END MODULE vakiot2
Lause PRIVATE muuttaa moduulin tunnukset oletusarvoisesti yksityisiksi.

PUBLIC-lauseella puolestaan mritelln tunnukset tyyppi ja maksimi julkisiksi.
9.8
Esimerkki: muunnosohjelma
Kappaleissa 9.3 ja 9.4 esitellyn yksikot-moduulin vakiotaulukko matkat nkyy moduulin ulkopuolelle. Tm johtaa virhetilanteeseen esimerkiksi seuraavassa tapauksessa:
USE yksikot
IMPLICIT NONE
REAL :: matkat
Moduulissa mritelty tunnusta matkat yritettiin siis kytt paikallisen

muuttujan nimen. Tm johtaa knnsaikaiseen virheeseen.
Jos moduulia kyttvss ohjelmassa kytetn saman nimisi tunnuksia
kuin moduulissa, on sekaannuksen vaara olemassa. Tmn vuoksi on aina
syyt mritell julkisiksi vain ne moduulin tunnukset, jotka ovat tarpeellisia moduulin kyttmiseen.
Voisimme ottaa kyttn moduulista yksikot vain muunnosohjelman:
USE yksikot, ONLY : muunna_r
Toinen mahdollisuus on nimet moduulin sisltm taulukko matkat uudestaan USE-lauseessa:

USE yksikot, pituusvakiot => matkat
Tss moduulin yksikot vakiotaulukolle matkat annetaan paikallinen nimi

pituusvakiot.
Taulukon matkat voi piilottaa moduulia kyttvilt ohjelmayksikilt. Niidenhn ei ole tarpeellista tiet muunnosohjelman toteutuksen yksityiskohtia. Tmn saa aikaan seuraavilla mrittelyill:
MODULE yksikot
IMPLICIT NONE
PRIVATE
REAL, DIMENSION(6), PARAMETER :: &
matkat = (/ &
0.01, &
! sentit
135
0.0254, &
0.3048, &
0.9144, &
1e3, &
1609.34 /)
PUBLIC :: muunna_r
CONTAINS
Funktion muunna_r mrittely
!
!
!
!
!
tuumat
jalat
jaardit
kilometrit
mailit
END MODULE yksikot
Moduulin ainoa julkinen olio on funktio muunna_r. Lisetuna paikallisten

vakioiden piilottamisessa on se, ett voimme vapaasti muuttaa toteutuksen
yksityiskohtia. Ainoastaan muunna_r-funktion kyttliittymn tulee sily.
9.9 Esimerkki: nollakohdan haku

Etsimme ratkaisua yhtllle ex = 5 x. Saamme muuttujan x arvon selville
hakemalla nollakohdan funktiolle f (x) = ex + x 5 (kuva 9.4).
150
100
f (x)
50
465
1
2
x
Kuva 9.4: Funktion f (x) = ex + x 5 nollakohdan hakeminen.
Lausekkeen ex +x5 arvon laskeva funktio fun voidaan sijoittaa moduuliin:

MODULE yhtalo
CONTAINS
FUNCTION fun(x) RESULT(fun_arvo)
IMPLICIT NONE
REAL :: fun_arvo
fun_arvo = EXP(x) + x - 5
END FUNCTION fun
END MODULE yhtalo
Jatkuvan funktion nollakohta voidaan hakea puolitushaulla (bisection). Aiemmin kappaleessa 7.4 sivulla 90 kytimme nollakohdan hakuun Newtonin
menetelm. Puolitushaussa lhdetn vlist [a, b], jossa funktion arvojen
136
Fortran 95/2003
f (a) ja f (b) tiedetn olevan erimerkkisi. Kullakin iteraatiolla vli puolitetaan, ja jatkoon otetaan se vli, jolla funktion arvot ovat edelleen erimerkkisi ptepisteiss. Funktiolle f (x) = ex + x 5 voidaan valita haun
aloittamiseen esimerkiksi vli [0, 5], koska f (0) = 4 < 0 ja f (5) = e5 > 0.
Seuraava moduuli sislt funktion puolitushaku nollakohdan etsintn:
MODULE nollakohta
IMPLICIT NONE
PRIVATE
REAL, PARAMETER :: toleranssi = 1e3*EPSILON(1.0)
PUBLIC :: puolitushaku
CONTAINS
FUNCTION puolitushaku(f, a, b) RESULT(hakupiste)
IMPLICIT NONE
INTERFACE
FUNCTION f(x) RESULT(f_arvo)
REAL :: f_arvo
END FUNCTION f
END INTERFACE
REAL, INTENT(IN) :: a, b ! Hakuvlin ptepisteet
REAL :: x1, x2, hakupiste, arvo
LOGICAL :: merkki
x1 = a
x2 = b
merkki = f(x1) < 0.0
IF (merkki .EQV. (f(x2) < 0)) THEN
WRITE (*,*) Ptepistearvot samanmerkkiset!
hakupiste = -HUGE(hakupiste)
ELSE
DO WHILE (ABS(x1 - x2) > toleranssi*ABS(x1))
hakupiste = 0.5*(x1+x2)
arvo = f(hakupiste)
IF ((arvo < 0.0) .EQV. merkki) THEN
x1 = hakupiste
ELSE
x2 = hakupiste
END IF
END DO
END IF
END FUNCTION puolitushaku
END MODULE nollakohta
Funktiossa puolitushaku mriteltiin muodollisen argumentin f kutsumuoto INTERFACE-lohkossa. Tten funktion sisll tehdn kutsumuodon
mukaiset tarkistukset kytettess funktiota f.
Lausekkeen f (x) = ex + x 5 nollakohta voidaan nyt hakea puolitushaulla
seuraavasti:
PROGRAM ratkaisu
USE yhtalo, ONLY : fun
USE nollakohta, ONLY : puolitushaku
IMPLICIT NONE
137
REAL :: x
x = puolitushaku(fun, 0.0, 5.0)
IF (ABS(x) < HUGE(x)) THEN
WRITE (*,*) Nollakohta:, x, fun(x)
END IF
END PROGRAM ratkaisu
Edell annoimme ONLY-mrittelyn mys moduulille yhtalo, koska tllin

pohjelmasta nkee suoraan, mist tunnus fun on perisin.
Ohjelman tulostus voisi olla seuraava:
Nollakohta:
1.3066101
2.4127960E-04
Ohjelman toimintaa on havainnollistettu kuvassa 9.4. Kyrn ylpuolelle

piirretyt luvut 1, 2, . . . , 6 ovat menetelmn perkkiset iteraatiopisteet.
9.10 Moduulissa mritellyt globaalit muuttujat

Moduulia nollakohta voi muuttaa siten, ett ratkaisun toleranssi on mahdollista asettaa halutuksi. Tm onnistuu korvaamalla moduulissa mritelty nimetty vakio toleranssi julkisella muuttujalla:
REAL, SAVE :: toleranssi = 1E3*EPSILON(1.0)
PUBLIC :: puolitushaku, toleranssi
Huomaa, ett muuttujalle toleranssi annettiin mre SAVE. Koska muuttuja toleranssi alustetaan mrittelylauseessa, saa se automaattisesti SAVEmreen, joten mreen voisi jtt poiskin.
Jos SAVE-mrett ei ole annettu eik muuttujaa alusteta mrittelylauseessa, silyy muuttujan arvo moduulia kyttvien proseduurien kutsukertojen
vlill vain siin tapauksessa, ett moduuli otetaan kyttn mys pohjelmassa.
Moduulia nollakohta voisi nyt kytt seuraavasti:
PROGRAM ratkaisu
USE yhtalo, ONLY : fun
USE nollakohta, ONLY : puolitushaku, toleranssi
IMPLICIT NONE
REAL :: x
toleranssi = 1E-5
x = puolitushaku(fun, 0.0, 5.0)
WRITE (*,*) Nollakohta:, x, fun(x)
END PROGRAM ratkaisu
Tss muutettiin toleranssin oletusarvoa ennen nollakohdan hakua. Toleranssin voisi tietysti mritell mys rutiinin puolitushaku valinnaiseksi
argumentiksi, jolloin ei tarvita erillist julkista muuttujaa.
138
Fortran 95/2003
9.11
Esimerkki: normaalijakautuneet
satunnaisluvut
Fortran 95:n standardialiohjelma RANDOM_NUMBER tuottaa tasajakautuneita

(pseudo)satunnaislukuja. (0, 1)-normaalijakautuneita satunnaislukuja voidaan tuottaa seuraavalla menetelmll:
1. tuotetaan tasajakautuneet satunnaisluvut x1 ja x2 (1, 1)
2. jos piste (x1 , x2 ) on yksikkympyrn sisll ja nollasta poikkeava, jatketaan seuraavaan vaiheeseen; muussa tapauksessa tuotetaan uudet satunnaisluvut

2 ln(x12 + x22 )
3. lasketaan suure t =
x12 + x22
4. luvut y1 = tx1 ja y2 = tx2 ovat normaalijakautuneita satunnaislukuja.
Menetelm on havainnollistettu kuvassa 9.5.
1

2 ln(x12 + x22 )
t=
x12 + x22
x2
y1 = tx1 ja y2 = tx2
1
1
x1
Kuva 9.5: Normaalijakautuneiden satunnaislukujen tuottaminen.
Seuraavan moduulin funktio normaali tuottaa normaalijakautuneen satunnaisluvun edell kuvatulla menetelmll. Koska algoritmi tuottaa kerralla
kaksi satunnaislukua, toinen niist otetaan talteen moduulin yksityiseen
muuttujaan talletettu_arvo.
MODULE satunnaisluvut
USE tarkkuus, ONLY : reaaliluku
IMPLICIT NONE
PRIVATE
REAL (KIND=reaaliluku), SAVE :: talletettu_arvo
LOGICAL, SAVE :: talletettu = .FALSE.
PUBLIC :: normaali
CONTAINS
FUNCTION normaali() RESULT(arvo)
IMPLICIT NONE
REAL (KIND=reaaliluku) :: arvo
REAL (KIND=reaaliluku), DIMENSION(2) :: x
REAL (KIND=reaaliluku) :: x_nelio, apu
139
IF (.NOT. talletettu) THEN

silmukka: DO
CALL RANDOM_NUMBER(x)
x(:) = 2.0*x(:) - 1.0
x_nelio = x(1)**2 + x(2)**2
IF (x_nelio < 1.0 .AND. x_nelio /= 0.0) THEN
EXIT silmukka
END IF
END DO silmukka
apu = SQRT(-2.0*LOG(x_nelio)/x_nelio)
talletettu_arvo = apu*x(1)
talletettu = .TRUE.
arvo = apu*x(2)
ELSE
talletettu = .FALSE.
arvo = talletettu_arvo
END IF
END FUNCTION normaali
END MODULE satunnaisluvut
Aliohjelma RANDOM_NUMBER tuottaa satunnaislukuja vlilt [0, 1), joten ohjelmassa skaalataan luvut vlille [1, 1). Algoritmissa tarvitaan satunnaislukuja vlilt (1, 1), mutta algoritmi hylk ne pisteet, joissa toinen koordinaateista saa arvon 1. Tmn vuoksi tt erikoistapausta ei tarvitse ksitell erikseen.
Moduulin ainoa julkinen olio on funktio normaali. Yksityinen looginen
muuttuja talletettu kertoo, onko edellisell funktion kutsukerralla luotu satunnaisluku kytettviss.
Seuraavassa kyttesimerkiss pyydetn sytteen normaalijakautuneiden
satunnaislukujen lukumr. Ohjelma tuottaa ja tulostaa satunnaisluvut
kutsumalla funktiota normaali.
PROGRAM satunnaistesti
USE satunnaisluvut, ONLY : normaali
IMPLICIT NONE
INTEGER :: i, n
WRITE (*,(A),ADVANCE=NO) Anna n:
READ (*,*) n
DO i = 1, n
WRITE (*,(F10.6)) normaali()
END DO
END PROGRAM satunnaistesti

Anna n: 6
-0.201469
0.970363
2.726932
-0.146014
1.872161
0.495932
Ohjelmassa satunnaistesti otetaan kyttn satunnaisluvut-moduuli.

Tm moduuli ottaa puolestaan kyttn kappaleessa 9.5 (sivu 131) mri-
140
Fortran 95/2003
tellyn moduulin tarkkuus. Kytettyjen moduulien hierarkkista jrjestyst

on havainnollistettu kuvassa 9.6.
pohjelma satunnaistesti
USE satunnaisluvut
USE tarkkuus
Kuva 9.6: Ohjelmayksikiden kutsukaavio.
9.12
Geneeriset proseduurit
Geneerinen proseduuri voi toimia eri tavalla sen mukaan, mink tyyppisi
argumentteja sille annetaan. Monet Fortranin standardifunktioista ovat geneerisi: esimerkiksi trigonometriselle funktiolle SIN voi antaa argumentiksi vaikkapa reaaliluvun, kompleksiluvun tai taulukkotyyppisen argumentin.
Geneerisyytt kutsutaan joskus mys termill ylilataaminen (overloading)
eli operaation mrittelyalueen laajentaminen.
Kappaleissa 9.3, 9.4 ja 9.8 mrittelimme funktion muunna_r, jota voitiin
kytt seuraavasti:
muunna_r(3.0, tuuma, cm)
Jos annamme funktiolle argumentiksi kokonaisluvun, saamme aikaan knnsaikaisen virheilmoituksen:

muunna_r(3, tuuma, cm)
Voimme kuitenkin mritell uuden funktion muunna_i, joka kutsuu aiemmin mritelty muunna_r-funktiota:
REAL FUNCTION muunna_i(x, alkup, kohde) RESULT(tulos)
IMPLICIT NONE
INTEGER, INTENT(IN) :: x
tulos = muunna_r(REAL(x), alkup, kohde)
END FUNCTION muunna_i
Jos funktio muunna_i sijoitetaan samaan moduuliin aiemmin mritellyn

muunna_r-funktion kanssa, voimme ottaa kyttn muunnosfunktiolle geneerisen nimen muunna. Tllin voimme kytt funktiokutsuja
muunna(3.0, tuuma, cm)
muunna(3, tuuma, cm)
Geneerinen nimi muunna tytyy mritell INTERFACE-lohkossa ennen moduulin CONTAINS-lausetta. Geneerist nime vastaavat moduulin proseduu-
141
rit voi luetella lauseessa MODULE PROCEDURE. Kaikkien tietty geneerist nime vastaavien proseduurien tytyy olla joko funktioita tai aliohjelmia.
MODULE yksikot
IMPLICIT NONE
PRIVATE
Edell esitetty vakiotaulukko matkat
INTERFACE muunna
MODULE PROCEDURE muunna_i, muunna_r
END INTERFACE
PUBLIC :: muunna
CONTAINS
REAL FUNCTION muunna_i(x, alkup, kohde) RESULT(tulos)
IMPLICIT NONE
INTEGER, INTENT(IN) :: x
REAL :: tulos
tulos = muunna(REAL(x), alkup, kohde)
END FUNCTION muunna_i
RECURSIVE FUNCTION muunna_r(x, alkup, kohde) RESULT(tulos)
Edell esitetty mrittely
END FUNCTION muunna_r
END MODULE yksikot
Moduulissa annettiin funktioille muunna_i ja muunna_r yhteinen geneerinen

nimi muunna. Lauseessa MODULE PROCEDURE ei esitell proseduurien kutsumuotoa, sill kntj lyt tarvittavat tiedot automaattisesti moduulin
proseduureista.
Funktiossa muunna_i kutsutaan muunnosfunktiota muunna reaalilukuargumenttia kytten. Tllin kynnistyy funktio muunna_r, joka tekee varsinaisen tyn.
Moduulin ainoa julkinen tunnus on geneerinen nimi muunna. Emme siis voi
viitata muunnosfunktion eri versioihin moduulin ulkopuolelta.
Kntj valitsee knnsaikana argumenttien tyypin perusteella oikean version geneerist nime vastaavista erityisnimist. Tmn vuoksi geneerist
tunnusta vastaavien proseduurien tulee olla erotettavissa toisistaan argumenttiensa tyypin, lajiparametrin tai ulottuvuuksien lukumrn perusteella.
Jos muodolliset argumentit eroavat ainoastaan jrjestyksens perusteella,
kyseess on geneerisen tunnuksen kannalta sama proseduuri. Seuraavassa
on virheellinen mrittely:
INTERFACE sub
SUBROUTINE sub1(x,i)
IMPLICIT NONE
REAL, INTENT(INOUT) :: x
142
Fortran 95/2003
INTEGER, INTENT(INOUT) :: i
END SUBROUTINE sub1
SUBROUTINE sub2(i,x)
IMPLICIT NONE
INTEGER, INTENT(INOUT) :: i
REAL, INTENT(INOUT) :: x
END SUBROUTINE sub2
END INTERFACE
Mrittelyss on virhe, sill aliohjelmaa sub voitaisiin kutsua avainsanaargumentteja kytten:

CALL sub(x=1.0, i=2)
Tllin ei en voida erottaa, kumpi versio aliohjelmista sub1 ja sub2 pitisi

valita.
Mys ulkoisille proseduureille voi antaa geneerisen nimen INTERFACE-lohkossa. Seuraavassa on tst esimerkki:
INTERFACE f
FUNCTION f_single(x)
IMPLICIT NONE
INTEGER, PARAMETER :: sp = KIND(1.0)
REAL(KIND=sp) :: x
END FUNCTION f_single
FUNCTION f_double(x)
IMPLICIT NONE
INTEGER, PARAMETER :: dp = &
SELECTED_REAL_KIND(2*PRECISION(1.0))
REAL(KIND=dp) :: x
END FUNCTION f_double
END INTERFACE
Riippuen geneerisen funktion f reaalilukuargumentin x lajista valitaan suoritettavaksi joko funktio f_single tai funktio f_double. Kaksoistarkkuuden lajiparametri on mritelty vaatimalla tyypilt tarkuutta kaksi kertaa
normaalitarkkuuden verran. Tmn pitisi olla melko koneriippumaton tapa mritell FORTRAN 77:n tyyppi DOUBLE PRECISION vastaava reaalilukulaji.
9.13
Operaattoreiden mrittely
Moduulien avulla on mahdollista mritell uusia operaattoreita ja antaa

vanhoille operaattoreille uusia merkityksi eri tietotyyppien yhteydess. Tt kutsutaan operaattorin ylilataamiseksi (operator overloading).
Ylilataamista voi kytt numeeristen standardioperaattoreiden (**, *, /, +
ja -) sek loogisten ja vertailuoperaattoreiden yhteydess. Mys sijoitusoperaatiolle voi mritell uusia merkityksi.
Valmiiksi mritelty operaattoria ei voi kuitenkaan mritell uudestaan alkuperisille tietotyypeille. Tten laskutoimitusten merkityst ei voi muuttaa
143
esimerkiksi seuraavassa lausekkeessa:

2*3 + 5.0/6
Voimme mys mritell uusia kyttjn mrittelemi operaattoreita, joiden nimi alkaa pisteell ja pttyy pisteeseen. Esittelemme myhemmin tss kappaleessa operaattorin .fmt. mrittelyn ja kytn.
Kyttjn mrittelemt yksiargumenttiset operaattorit ovat suoritusjrjestykseltn vahvemmat kuin muut Fortranin lausekkeiden termit. Siten esimerkiksi lausekkeiden
(A, // (.fmt. 10) // )
(A, // .fmt. 10 // )
suoritusjrjestys on sama. Kyttjn mrittelemt kaksiargumenttiset operaattorit ovat puolestaan suoritusjrjestykseltn heikoimmat, joten tllaisia operaattoreita sisltvien lausekkeiden yhteydess voivat sulut olla tarpeen.
Luomme seuraavassa moduulin muotoilu, jossa mrittelemme uusia operaattoreita merkkijonoille. Ainoa merkkijonoille mritelty operaatio on (vertailuoperaatioiden lisksi) liitosoperaatio (//). Kytettvissmme on siten
operaattorit **, *, /, + ja -.
9.13.1 Kaksiargumenttiset operaattorit

Voimme mritell operaattorille * merkkijonojen yhteydess seuraavan uuden kytttavan:
n*merkkijono
merkkijono*n
Tss n on kokonaislukutyyppi. Niden lausekkeiden tuloksena olkoon

merkkijono, jossa alkuperist merkkijonoa on toistettu n kertaa. Seuraavassa on thn tarvittavat mrittelyt:
MODULE muotoilu
IMPLICIT NONE
INTERFACE OPERATOR(*)
MODULE PROCEDURE toista_mjono, toista_mjono_2
END INTERFACE
CONTAINS
FUNCTION toista_mjono(kertaa, mjono) RESULT(uusi_mjono)
IMPLICIT NONE
INTEGER, INTENT(IN) :: kertaa
CHARACTER(LEN=*), INTENT(IN) :: mjono
CHARACTER(LEN=kertaa*LEN(mjono)) :: uusi_mjono
uusi_mjono = REPEAT(mjono,kertaa)
END FUNCTION toista_mjono
FUNCTION toista_mjono_2(mjono,kertaa) RESULT(uusi_mjono)
IMPLICIT NONE
INTEGER, INTENT(IN) :: kertaa
144
Fortran 95/2003
CHARACTER(LEN=*), INTENT(IN) :: mjono

CHARACTER(LEN=kertaa*LEN(mjono)) :: uusi_mjono
uusi_mjono = REPEAT(mjono,kertaa)
END FUNCTION toista_mjono_2
END MODULE muotoilu
Standardifunktio REPEAT toistaa merkkijonoa niin monta kertaa kuin haluamme. Moduulissa on tarpeen mritell erillinen funktio kummallekin
toisto-operaattorin kytttavalle (toistokerrat annetaan joko ennen merkkijonoa tai sen jlkeen).
Seuraavassa on esimerkki moduulin kytst:
PROGRAM muotoilutesti
USE muotoilu
WRITE (*,(A)) 4*Hurraa!
WRITE (*,(A)) 3*Hei! *2
END PROGRAM muotoilutesti
Tm ohjelma tulostaa seuraavaa:

Hurraa! Hurraa! Hurraa! Hurraa!
Hei! Hei! Hei! Hei! Hei! Hei!
Jlkimmisess tapauksessa toistettiin merkkijonoa ensin kolme kertaa ja

saatua tulosta viel kaksi kertaa. Saimme siis aikaan haluamamme tuloksen.
Edell mritellyt funktiot toista_mjono ja toista_mjono_2 eroavat toisistaan vain argumenttiensa jrjestyksen suhteen. Kntj osaa valita oikean
version vertaamalla operaattorin * argumenttien jrjestyst niden funktioiden argumenttien jrjestykseen. Seuraava INTERFACE-mrittely olisi kuitenkin laiton:
INTERFACE toista
MODULE PROCEDURE toista_mjono, toista_mjono_2
END INTERFACE toista
Selit, miksi mrittelyss on virhe! (Vihje: voit antaa funktiolle avainsanaargumentteja.)
9.13.2 Yksiargumenttiset operaattorit

Normaali kokonaislukujen I-muotoilukoodi sijoittaa luvun kiinten kokoiseen kenttn. Kokonaislukuja tulostettaessa olisi kuitenkin hyv olla kytss muotoilukoodi, joka sijoittaisi kokonaisluvun juuri tarpeeksi leven
kenttn. (Huomaa, ett Fortran 95 -standardiin kuuluu minimileveysformaatti, esimerkki tst on muotoilukoodi I0.)
Seuraavassa mrittelemme operaattorin .fmt., joka tuottaa tarvittavan minimileveyden muotoilukoodin kokonaislukumuuttujalle. Siten lausekkeen
.fmt. 101
tuloksena on muotoilukoodi I3 ja lausekkeen .fmt. -1 tuloksena on

muotoilukoodi I2. Kokonaislukujen muotoilukoodeista kerrotaan enemmn kappaleessa 12.5.1 sivulla 198.
145
Seuraavat mrittelyt voi list edell kytettyyn muotoilu-moduuliin. Emme kyt Fortran 95:n standardioperaattoreita vaan luomme uuden nimetyn
operaattorin .fmt. (nimen tytyy alkaa pisteell ja ptty pisteeseen).
INTERFACE OPERATOR(.fmt.)
MODULE PROCEDURE minimileveyskoodi
END INTERFACE
CONTAINS-lauseen jlkeen tulee funktion mrittely:

FUNCTION minimileveyskoodi(n) RESULT(mjono)
IMPLICIT NONE
CHARACTER(LEN=3) :: mjono
INTEGER :: pituus
pituus = desimaalit(n)
IF (n < 0) pituus = pituus + 1
WRITE (mjono, (I3)) pituus
mjono = I // TRIM(ADJUSTL(mjono))
CONTAINS
IMPLICIT NONE
INTEGER, INTENT(IN) :: i
INTEGER :: desim
INTEGER :: apu
INTRINSIC ABS
desim = 1
apu = ABS(i)
apu = apu/10
desim = desim + 1
END DO
END FUNCTION minimileveyskoodi
Funktio palauttaa muotoilukoodin kolmen merkin pituisessa merkkijonossa. Kokonaisluvun vaatiman kentn leveys (ilman etumerkki) saadaan selville sisisell funktiolla desimaalit. Tmn jlkeen tulostetaan tarvittavan
kentn pituus merkkijonoon mjono ja listn muotoilukoodin alkuun viel
merkki I.
Edell mritelty operaattoria .fmt. voi nyt kytt seuraavasti:
USE muotoilu
IMPLICIT NONE
INTEGER :: m = 1996
CHARACTER(LEN=10) :: formaatti
formaatti = (A, // .fmt. m // ,A)
WRITE (*,(A)) Muotoilukoodi: // formaatti
WRITE (*, formaatti) Luku on , m, .
m = -100000*m
formaatti = (A, // .fmt. m // ,A)
146
Fortran 95/2003

Tmn ohjelman tulostus on seuraavaa:

Muotoilukoodi: (A,I4 ,A)
Luku on 1996.
Muotoilukoodi: (A,I10,A)
Luku on -199600000.
9.13.3 Sijoitusoperaation mrittely uudelleen

Mys sijoitusoperaation merkitys on mahdollista mritell uusille tyypeille. Fortranissa ei ole mritelty kokonaisluvun sijoittamista merkkijonoon,
joten voimme mritell tmn operaation merkityksen itse. Voisimme kytt sijoitusoperaatiota hyvksi esimerkiksi seuraavasti:
USE muotoilu
IMPLICIT NONE
INTEGER :: m = 1996
CHARACTER(LEN=10) :: tulostus
tulostus = 1996
WRITE (*,(A)) Vuosi on // TRIM(tulostus) // .
Ohjelman tulostus voisi olla seuraavaa:

Vuosi on 1996.
Tarvittavat lisykset moduuliin muotoilu ovat seuraavat:

MODULE muotoilu
IMPLICIT NONE
INTERFACE ASSIGNMENT(=)
MODULE PROCEDURE mjono_kokonaisluku
END INTERFACE
CONTAINS
SUBROUTINE mjono_kokonaisluku(mjono, n)
IMPLICIT NONE
CHARACTER(LEN=*), INTENT(OUT) :: mjono
CHARACTER(LEN=RANGE(n)+2) :: apu
WRITE (apu,( // .fmt. n // )) n
mjono = ADJUSTL(apu)
END SUBROUTINE mjono_kokonaisluku
END MODULE muotoilu
Aliohjelmassa kokonaisluku tulostetaan kokonaisluku n tarvittavan pituiseen merkkijonomuuttujaan apu kytten sisist tiedostoa (sivu 209). Tulostamiseen kytetn operaattorin .fmt. tuottamaa muotoilukoodia. Merkkijonoargumentti mjono on mritelty seuraavasti:
CHARACTER(LEN=*), INTENT(OUT) :: mjono
147
Tllin sijoituslauseen vasemmalla puolella voi olla mink pituinen merkkijono tahansa.
9.14
Yhteenveto operaattoreiden mrittelyst
Operaattorit mritelln INTERFACE-lohkossa seuraavasti:

INTERFACE OPERATOR(operaattorin_tunnus)
[MODULE PROCEDURE proseduurin_tunnus &
[, proseduurin_tunnus]...]...
END INTERFACE
Kun mrittelemme yksiargumenttisen operaattorin, tulee INTERFACElohkossa esiintyvien proseduurien olla yksiargumenttisia funktioita, joiden muodollisella argumentilla on mre INTENT(IN). Jos luettelemme
INTERFACE-lohkossa useamman funktion nimet, tytyy niden argumenttien tyypin poiketa toisistaan. Tm sen vuoksi, ett kntj pystyy knnsaikana valitsemaan, mik funktiokutsu tulee sijoittaa operaattorin paikalle.
Kaksiargumenttista operaattoria mriteltess tulee INTERFACE-lohkossa
esiintyvien proseduurien olla kaksiargumenttisia funktioita, joiden argumenteilla on mre INTENT(IN). Ensimminen muodollinen argumentti vastaa operaattorin vasenta argumenttia ja toinen oikeaa argumenttia.
Sijoitusoperaattorille mritelln uusi merkitys seuraavasti:
[MODULE PROCEDURE proseduurin_tunnus &
[, proseduurin_tunnus]...]...
END INTERFACE
Lohkossa esiintyvien proseduurien tulee olla aliohjelmia, joiden ensimminen argumentti on tyyppi INTENT(OUT) ja toinen argumentti puolestaan tyyppi INTENT(IN). Nm muodolliset argumentit vastaavat sijoituslauseen vasenta ja oikeaa puolta. Muodollisten argumenttien tyyppien tulee
poiketa valmiiksi mritellyist sijoituslauseen merkityksist sek muista
kyseisess INTERFACE-lohkossa esiintyvien aliohjelmien tyypeist.
9.15
Funktioiden ja operaattorien kytttavat
Edell mriteltiin standardioperaattorille * uusi merkitys merkkijonojen

ksittelyss. Useimmiten on kuitenkin selkemp kytt operaattorinotaation sijaan funktiokutsuja, varsinkin jos standardioperaation merkitys ei
ole itsestn selv.
Esimerkiksi merkinnn
2*Hurraa!
148
Fortran 95/2003
sijaan on selkemp kytt standardifunktiota REPEAT:

REPEAT(Hurraa! ,2)
Harjoitustehtvn on edell mriteltyj merkkijono-operaatioita vastaavien funktioiden mrittely. Nit merkkijonofunktioita voisi kytt vaikkapa seuraavasti:
USE muotoilu
IMPLICIT NONE
INTEGER :: m = 1996
CHARACTER(LEN=10) :: tulostus, formaatti
tulostus = mjono(m)
WRITE (*,(A)) Vuosi on // TRIM(tulostus) // .
formaatti = (A, // fmt(m) // ,A)
Funktio mjono muuttaa kokonaisluvun merkkijonoksi. Funktio fmt tuottaa

kokonaisluvun tulostamiseen tarvittavan muotoilukoodin.
Operaattoreita kannattaa kytt lhinn silloin, kun operaation merkitys
on itsestn selv. Luvussa 10 (sivu 152) luodaan kolmiulotteisia vektoreita
vastaava tietotyyppi sek mritelln tlle tyypille yhteen- ja vhennyslaskuoperaatiot jne. Tss tapauksessa merkint v = v1 + v2 on luonnollinen
tapa esitt vektorien yhteenlasku.
9.16
Muita moduulien kyttmahdollisuuksia
Moduuleissa voi mritell uusia (rakenteisia) muuttujatyyppej ja niihin

liittyvi operaatioita. Tst kerrotaan tarkemmin luvussa 10 (sivu 152).
Moduuliin voi sijoittaa ulkoisiin funktioihin liittyvi INTERFACE-lohkoja, jolloin kytettess vaikkapa aliohjelmakirjastoa voidaan proseduurien kutsumuodot tarkistaa knnsaikana.
Moduuleihin voi sijoittaa NAMELIST-ryhmien mrittelyj, jolloin tiedoston
syttmuodon muuttamiseksi riitt muuttaa moduulissa tehtvi mrittelyj. NAMELIST-ryhmist kerrotaan sivulla 210.
9.17
Yhteenveto
Moduuleita voi kytt tietotyyppien, datan ja nihin liittyvien operaatioiden

mrittelemiseen yhten kokonaisuutena. Kyttmll PRIVATE-mrett ja
-lausetta on mahdollista piilottaa toteutuksen yksityiskohdat moduulin ulkopuolelta. Tllin voidaan olla varmoja siit, ett toteutuksen muuttamisen
ei tarvitse johtaa koko ohjelmiston uudelleen kirjoittamiseen.
149
Moduuli mritelln seuraavasti:

MODULE tunnus
[mrittelylauseet]
[CONTAINS
moduulin_proseduuri
[moduulin_proseduuri]...]
END [MODULE [tunnus]]
Moduuli otetaan kyttn USE-lauseella:

USE moduuli[, paikallinen_nimi => nimi_moduulissa]...
USE moduuli, ONLY : [[paikallinen_nimi =>] nimi_moduulissa &
[, [paikallinen_nimi =>] nimi_moduulissa]...]
Operaattori ja sijoituslause mritelln INTERFACE-lohkossa:

INTERFACE OPERATOR(operaattori)
[kutsumuodon_mrittelylohko]...
[MODULE PROCEDURE tunnus[, tunnus]...]...
END INTERFACE
END INTERFACE
Tss luvussa kytiin nopeassa tahdissa lpi moduulien kyttmahdollisuuksia. Lis esimerkkej lytyy luvusta 14 (sivu 234). Koska moduuliajattelun oppii ainoastaan ohjelmoimalla, kannattaa seuraaviin harjoitustehtviin perehty kunnolla! Voit mys toteuttaa jonkin oman ohjelmointitehtvsi kytten moduuleita.
Harjoitustehtvi
1. Lis merimailin ja valovuoden pituusyksikt kappaleessa 9.12 sivulla
140 esitettyyn muunnosohjelmaan.
2. Mrittele geneerinen aliohjelma vaihda, jonka avulla voi vaihtaa argumenttien arvot keskenn:
INTEGER :: i, j
REAL :: x, y
CHARACTER(LEN=10) :: rivi1, rivi2
...
CALL vaihda(i,j)
CALL vaihda(x,y)
CALL vaihda(rivi1,rivi2)
3. Laajenna edell kyttmsi vaihda-aliohjelman toiminta-alueeksi mys

yksi- ja kaksiulotteiset taulukot. Niden alkiot vaihdetaan keskenn.
4. Muuta kappaleen 9.9 (sivu 135) nollakohdan hakurutiinia siten, ett saat
mys selville haussa tarvittujen vlin puolitusten lukumrn.
150
Fortran 95/2003
5. Muuta kappaleen 9.9 (sivu 135) nollakohdan hakurutiinia siten, ett menetelmn kytetn Newtonin menetelm (katso mallia kappaleesta
7.4 sivulta 90).
6. Mrittele merkkijonojen muunnosmoduuli, jonka sisltmt funktiot
isot_merkit ja pienet_merkit muuttavat argumenttinaan saamansa
merkkijonot isoiksi tai pieniksi kirjaimiksi. Ota huomioon mys skandinaaviset merkit!
7. Mrittele funktio fmt, joka palauttaa merkkijonona tss luvussa mritelty operaattoria .fmt. vastaavan kokonaisluvun muotoilukoodin
seuraavasti:
formaatti = (A, // fmt(m) // ,A)
8. Mrittele funktio mjono, joka muuntaa kokonaisluvun merkkijonoksi

seuraavaan tapaan:
tulostus = mjono(m)
9. Mrittele moduulissa satunnaislukuja tuottava funktio rnd, joka palauttaa annetun mrn tasajakautuneita satunnaislukuja. Funktiolla on
kaksi valinnaista argumenttia, joilla voi mrt, mille vlille [a, b) satunnaisluvut skaalataan. Seuraavassa on funktion kyttesimerkkej:
REAL, DIMENSION(n) :: x, y
x = rnd(n)
y = rnd(n,-1.0,1.0)
10. Sarjassa tai rinnakkain sijoitettujen vastusten resistanssi R lasketaan

kaavoilla
R = R + R ,
resistanssit sarjassa,
1
2
1/R = 1/R1 + 1/R2 , resistanssit rinnakkain.
Mrittele reaalilukumuuttujia ksittelevt operaattorit, joita voidaan
kytt seuraavasti:
REAL :: r, r1, r2
r = r1 .sarjassa. r2
r = r1 .rinnakkain. r2
11. Laajenna edell mriteltyjen operaattorien kyttaluetta siten, ett niit voi kytt mys yksiargumenttisina operaattoreina seuraavasti:
REAL, DIMENSION(5) :: r0
REAL :: r
r = .sarjassa. r0
r = .rinnakkain. r0
Tss taulukkoon r0 on sijoitettu viiden vastuksen resistanssien arvot.

12. Mrittele yksiargumenttiset operaattorit .karvo. ja .khaj., jotka laskevat yksiulotteisen reaalilukutaulukon alkioiden keskiarvon ja keskihajonnan.
151
13. Laajenna edell mriteltyj operaattoreita siten, ett voit antaa operaattorin vasemmanpuoleisena argumenttina loogisen taulukon, joka
kertoo mitk alkiot tulee ottaa mukaan keskiarvon tai keskihajonnan
laskemiseen:
keskiarvo = (x >= -1 .AND. x <= 1) .karvo. x
14. Mrittele yksiargumenttiset operaattorit + ja -, jotka muuttavat merkkijonon isoiksi tai pieniksi kirjaimiksi:
WRITE (*,*) +Isoiksi kirjaimiksi!
WRITE (*,*) -PIENET KIRJAIMET!
15. Mrittele kaksiargumenttinen operaattori -, joka poistaa merkkijonosta annetut merkit ja lis merkkijonon loppuun vastaavan mrn vlilyntej:
WRITE (*,*) Teksti - k
WRITE (*,*) Teksti - ts
Tss tulostuvien merkkijonojen tulisi olla Testi ja Teki
16. Mrittele operaattori /, joka liitt yhteen etuja sukunimen sisltvt merkkijonot ja muuttaa kummankin ensimmisen kirjaimen isoksi
ja loput pieniksi. Nimien vliin tulee yksi vlilynti. Seuraavassa on esimerkki operaattorin kytst:
mjono = etu
SUKUA
Tuloksen pitisi olla merkkijono Etu Sukua.

17. Kirjoita moduuli fibomod, jossa mritelty funktio fibo laskee ns. Fibonaccin lukuja:
x = 1, x = 1,
1
2
xn = xn1 + xn2 , n > 2.
Funktion tulisi muistaa aiemmin lasketut luvut annettuun maksimiarvoon asti. Seuraavassa on moduulin kyttesimerkki:
PROGRAM fibotest
USE fibomod, ONLY : fibo, fibo_max
fibo_max = 100
WRITE (*,*) fibo(10): , fibo(10)
WRITE (*,*) fibo(12): , fibo(12)
END PROGRAM fibotest
Kyt luvussa 11 esiteltyj dynaamisia taulukoita aiemmin laskettujen

arvojen tallettamiseen. Voit mys yksinkertaistaa tehtv kyttmll
vakiokokoista taulukkoa.
18. Toteuta kappaleessa 9.10 ehdotettu muutos nollakohta-moduuliin: toleranssi voidaan antaa valinnaisena argumenttina puolitushaku-rutiinille. Jos valinnaista argumenttia ei ole annettu, kyt moduulissa mritelty oletusarvoa.
152
Fortran 95/2003
10
Rakenteiset tietotyypit
Esittelemme tss luvussa rakenteisten tietotyyppien mrittelyn ja annamme kyttesimerkkej rakenteisista tyypeist. Kerromme mys operaattoreiden mrittelyst ja kytst sek abstraktien tietotyyppien luomisesta.
10.1
Rakenteisten tyyppien mrittely
Aiemmista FORTRAN-versioista poiketen Fortran 95 sislt mahdollisuuden kytt rakenteisia tietotyyppej (derived type) taulukoiden ja skalaarien lisksi. Rakenteisten tietotyyppien kytll voi selkeytt ohjelmaa kokoamalla yhteen muuttujaan toisiinsa liittyvi tietoja.
Yhdistmll moduulit ja rakenteiset tietotyypit voimme mritell tietorakenteillemme halutunlaisia operaatioita. Toisin sanoen voimme rakentaa
abstrakteja tietotyyppej, jotka koostuvat datasta sek datalle mritellyist operaatioista. Tllaisesta lhestymistavasta on esimerkkej myhemmin
tss luvussa.
Oman tietotyypin mrittely nytt esimerkiksi tlt:
TYPE vektorityyppi
REAL :: x
REAL :: y
REAL :: z
END TYPE vektorityyppi
Tm tietotyyppi koostuu kolmesta reaalilukutyyppisest alkiosta. Kun tietotyyppi on mritelty, voidaan uutta tyyppi oleva muuttuja mritell ohjelmassa esimerkiksi seuraavilla lausekkeilla:
TYPE(vektorityyppi) :: v
TYPE(vektorityyppi), DIMENSION (100) :: solmut
Rakenteista tietotyyppi olevan muuttujan alkioihin voidaan viitata prosenttimerkin (%) avulla seuraavasti:
v % y = 1.1
solmut(1:100) % x = 0.0
solmut(1:100) % y = 1.0
10. Rakenteiset tietotyypit
153
Tyyppimrittely luo mys tyyppirakenteen alustimen, joka palauttaa arvonaan tmn tyyppisen tieto-olion. Tyyppialustimen nimi on sama kuin tyypinkin.
Seuraavassa sijoitamme rakenteiseen muuttujaan v luvut (1.0, 2.0, 3.0), jotka WRITE-lause tulostaa.
v = vektorityyppi( 1.0,2.0,3.0 )
WRITE(*,*) v % x, v % y, v % z
Alustuksen voisi tehd mys muuttujan mrittelyn yhteydess:

TYPE(vektorityyppi) :: v = vektorityyppi( 1.0,2.0,3.0 )
Rakenteista tyyppi voi kytt proseduurin muodollisena parametrina, jos

tyyppi on tunnettu proseduurille. Proseduuri voi tuntea tyypin monella tavalla: proseduuri on rakenteisen tyypin mrittelevn ohjelmayksikn sisinen proseduuri, proseduurissa otetaan kyttn rakenteisen tyypin mrittelev moduuli tai proseduuri mrittelee tyypin itse. Viimeisin tapa ei ole
suositeltava, koska mys kutsuvan proseduurin on ollut pakko mritell
tyyppi, jolloin on helppo saada aikaan ristiriitaisia mrittelyj.
Olkoon esimerkiksi mriteltyn ulkoinen aliohjelma huono:
SUBROUTINE huono(a)
IMPLICIT NONE
TYPE konflikti
REAL :: a
END TYPE konflikti
TYPE(konflikti) :: a
jne.
END SUBROUTINE huono
Seuraavassa pohjelmassa kutsutaan tt aliohjelmaa, mutta mritelln

tyyppi konflikti uudestaan:
PROGRAM tyyppikonflikti
IMPLICIT NONE
TYPE konflikti
INTEGER :: a
END TYPE konflikti
TYPE(konflikti) :: a
CALL huono(a)
END PROGRAM tyyppikonflikti
Pohjelman ja aliohjelman kyttm mrittely rakenteelle konflikti on

tss esimerkiss erilainen. Proseduurin muodollisena parametrina olevan
muuttujan tyypin mrittely proseduurin sisll on perusteltua ainoastaan,
jos mrittely ei ole saatavilla mistn muualta, eli esimerkiksi jos kutsuva
proseduuri on kirjoitettu jollain toisella ohjelmointikielell. Tllinkin hyv
ohjelmointityyli olisi koota vastintyyppimrittelyt moduuleihin, etenkin
jos tyyppimrittelyj kytetn useammassa proseduurissa.
Rakenteisen tyypin komponentti voi olla mys toinen rakenteinen tyyppi.
Kolmioiden ksittelyyn luomme rakenteisen tyypin kolmiotyyppi:
154
Fortran 95/2003
TYPE kolmiotyyppi
REAL :: pinta_ala
TYPE(vektorityyppi) :: normaali
TYPE(vektorityyppi), DIMENSION(3) :: karkipisteet
END TYPE kolmiotyyppi
Tyypin kolmiotyyppi komponentille normaali voi asettaa arvon seuraavasti:

TYPE(kolmiotyyppi) :: kolmio
kolmio % normaali % x = 0.0
kolmio % normaali % y = 0.0
kolmio % normaali % z = 1.0
tai vaihtoehtoisesti tyypin alustimen avulla:

kolmio % normaali = vektorityyppi( 0.0,0.0,1.0 )
Alustuksen voi hoitaa mys mrittelylauseessa. Seuraavassa on esimerkki

tst:
PROGRAM kolmio_testi
IMPLICIT NONE
TYPE vektorityyppi
REAL :: x
REAL :: y
REAL :: z
TYPE kolmiotyyppi
REAL :: pinta_ala
TYPE(kolmiotyyppi) :: &
kolmio = kolmiotyyppi(1.0, &
vektorityyppi( 0.0,0.0,1.0 ), &
(/ vektorityyppi( 0.0,0.0,0.0 ), &
vektorityyppi( 1.0,-1.0,0.0 ), &
vektorityyppi( 1.0,1.0,0.0 ) /) )
WRITE (*,*) kolmio % pinta_ala
WRITE (*,*) kolmio % normaali
WRITE (*,*) kolmio % karkipisteet(1)
END PROGRAM kolmio_testi
Ohjelmassa kytettiin taulukkoalustinta (/ ... /) muodostamaan kolmialkioinen taulukko tyypin vektorityyppi alkioista.
Fortran-standardi ei mrittele oletusarvoista rakenteen alkioiden talletusjrjestyst muistissa (kuten ei taulukon alkioidenkaan), vaan tm on toteutuskohtaista. Rakenteen alkiojrjestyksen voi kuitenkin pakottaa vastaa-
155
maan mrittelyjrjestyst antamalla tyyppimrittelyn sisll SEQUENCEmreen:

TYPE vektorityyppi
SEQUENCE
INTEGER :: n
REAL :: x
REAL :: y
REAL :: z
Mrett SEQUENCE tarvitaan kytnnss vain silloin, kun rakenteisen tyypin muuttujia halutaan vlitt eri ohjelmointikielten vlill.
Rakenteisen tyypin alkioille voi antaa mys oletusarvot suoraan tyypin mrittelyss:
PROGRAM kolmio_testi
IMPLICIT NONE
INTEGER, PARAMETER :: rkd = SELECTED_REAL_KIND(6,30)
REAL, PARAMETER :: alkuarvo = HUGE(1.0_rkd)
TYPE vektorityyppi
REAL(KIND=rkd) :: x = alkuarvo
REAL(KIND=rkd) :: y = alkuarvo
REAL(KIND=rkd) :: z = alkuarvo
TYPE kolmiotyyppi
REAL(KIND=rkd) :: pinta_ala = alkuarvo
TYPE(kolmiotyyppi) :: kolmio
WRITE (*,*) kolmio % normaali
END PROGRAM kolmio_testi
Tm ohjelma voisi tulostaa seuraavaa:

3.4028235E+38
3.4028235E+38
3.4028235E+38
Kolmion normaali alustettiin suurimmalla esitettviss olevalla reaaliluvulla

tyypin vektorityyppi mrittelyn perusteella.
10.2 Esimerkki: vektorilaskentamoduuli

Mrittelemme seuraavassa avaruusvektorityypin ja thn tyyppiin kohdistuvia operaatioita. Kokoamme tyyppimrittelyn ja tarvittavat vektorioperaatiot moduuliin vektorilaskenta.
Vektori koostuu komponenteista (x, y, z). Vektoreille on mritelty moduu-
156
Fortran 95/2003
lissa seuraavat operaatiot:

Arvon sijoitus vektorille. Tmn voi tehd tyyppirakenteen alustimen
avulla, esimerkiksi
v = vektorityyppi( 0.0,1.0,0.0 )
tai sijoittamalla arvot suoraan tyypin alkioihin:

v % x = 0.0
v % y = 0.0
v % z = 0.0
Jljempn kerrotaan, miten sijoitusoperaatio toteutetaan, jos vektorin

alkiot mritelln yksityisiksi, jolloin rakenteen alustinta tai suoraa
sijoitusta ei voi kytt.
v3 = v1+v2: Kahden vektorin summavektori.
v3 = v1-v2: Kahden vektorin erotusvektori.
pistetulo(v1,v2): Kahden vektorin komponenttien tulojen summa.
ristitulo(v1,v2): Kahden vektorin ristitulo.
ABS(v): Vektorin euklidinen normi eli pituus.
Seuraavassa on esitetty moduulin mrittely. Luomme ensin rakenteisen tyypin sek mrittelemme operaattoreiden + ja - ja standardifunktion ABS ylilatauksen:
MODULE vektorilaskenta
IMPLICIT NONE
TYPE vektorityyppi
REAL :: x
REAL :: y
REAL :: z
INTERFACE OPERATOR(+)
MODULE PROCEDURE vektorisumma
END INTERFACE
INTERFACE OPERATOR(-)
MODULE PROCEDURE vektorierotus
END INTERFACE
INTERFACE ABS
MODULE PROCEDURE vektorinormi
END INTERFACE
CONTAINS
Seuraavassa esiteltvien funktioiden mrittelyt.
END MODULE vektorilaskenta
Voimme mritell moduuliin vektorilaskenta funktioita, jotka ksittelevt tyypin vektorityyppi tieto-olioita. Aluksi mrittelemme funktiot,
157
jotka laskevat kahden vektorin summa- ja erotusvektorit. Nm mriteltiin

yll operaattoreiden + ja - ylilatauksella kutsuttaviksi. Huomaa, ett mre
INTENT(IN) on pakollinen operaattorin mrittelevn funktion muodollisille argumenteille.
FUNCTION vektorisumma(v1, v2) RESULT(summa_vektori)
! Funktio palauttaa arvonaan vektoreiden
! v1 ja v2 summavektorin
IMPLICIT NONE
TYPE(vektorityyppi) :: summa_vektori
TYPE(vektorityyppi), INTENT(IN) :: v1, v2
summa_vektori % x = v1 % x + v2 % x
summa_vektori % y = v1 % y + v2 % y
summa_vektori % z = v1 % z + v2 % z
END FUNCTION vektorisumma
FUNCTION vektorierotus(v1, v2) RESULT(erotus_vektori)
! v1 ja v2 erotusvektorin
IMPLICIT NONE
TYPE(vektorityyppi) :: erotus_vektori
erotus_vektori % x = v1 % x - v2 % x
erotus_vektori % y = v1 % y - v2 % y
erotus_vektori % z = v1 % z - v2 % z
END FUNCTION vektorierotus
Lopuksi teemme funktiot, jotka mrittelevt loput vektorityyppiin kohdistuvista operaatioista: pistetulo, vektorin pituus ja vektoriristitulo.
FUNCTION pistetulo(v1, v2) RESULT(tulos)
! v1 ja v2 pistetulon
IMPLICIT NONE
REAL :: tulos
tulos = v1 % x * v2 % x
tulos = tulos + v1 % y * v2 % y
tulos = tulos + v1 % z * v2 % z
END FUNCTION pistetulo
FUNCTION vektorinormi( v ) RESULT(pituus)
! Funktio palauttaa arvonaan vektorin v pituuden
IMPLICIT NONE
REAL :: pituus
TYPE(vektorityyppi), INTENT(IN) :: v
pituus = SQRT(pistetulo(v,v))
END FUNCTION vektorinormi
158
Fortran 95/2003
FUNCTION ristitulo(v1, v2) RESULT(tulos)

! v1 ja v2 ristitulon
IMPLICIT NONE
TYPE(vektorityyppi) :: tulos
tulos % x = v1 % y * v2 % z - v1 % z * v2 % y
tulos % y = v1 % z * v2 % x - v1 % x * v2 % z
tulos % z = v1 % x * v2 % y - v1 % y * v2 % x
END FUNCTION ristitulo
Alla on pieni testiohjelma vektorimoduulin kokeiluun:

PROGRAM vektoritesti
USE vektorilaskenta
IMPLICIT NONE
TYPE(vektorityyppi) :: u, v, w
REAL :: k, pituus
CHARACTER(LEN=*), PARAMETER :: form = (A,3F7.3)
u = vektorityyppi( 1.0, 0.0, 0.0)
v = vektorityyppi(-1.0, 1.0, 1.0)
w = ristitulo(u,v)
k = pistetulo(u,v)
pituus = ABS(u)
WRITE(*,form)
WRITE(*,form)
WRITE(*,form)
WRITE(*,form)
WRITE(*,form)
END PROGRAM
Vektori u: , u
Vektori v: , v
Vektorin u pituus: , pituus
Vektoreiden u ja v ristitulo: , w
Vektoreiden u ja v pistetulo: , k

Vektori u:
1.000 0.000 0.000
Vektori v: -1.000 1.000 1.000
Vektorin u pituus:
1.000
Vektoreiden u ja v ristitulo:
0.000 -1.000
Vektoreiden u ja v pistetulo: -1.000
10.3
1.000
NULL-funktio
Fortran 95:ess (mutta ei Fortran 90:ss) osoitintaulukot voi alustaa kohteesta irrotetuiksi (disassociated) NULL-funktion avulla:
REAL, DIMENSION(:), POINTER
Mys rakenteiset tyypit voi alustaa:
:: t => NULL()
159
TYPE :: pinotyyppi
REAL, DIMENSION(:), POINTER :: arvot => NULL()
INTEGER :: huippu = -1
END TYPE pinotyyppi
TYPE(pinotyyppi) :: &
pino, & ! Oletusalustus
pino2 = pinotyyppi(NULL(),0)
Tss alustimme osoitintaulukot kohteesta irrotetuiksi NULL-funktion avulla.
10.4 Julkisuus ja yksityisyys

Vektorityypin mrittelyss ei edell kerrottu, voiko moduulin kyttj viitata suoraan itse vektorin alkioihin, vai voiko vektorityypin muuttujaa ksitell vain moduulissa mriteltyjen operaatioiden kautta. Oletusarvoisesti,
jos tyypin mrittelyss ei muuta sanota, tyypin alkiot ovat julkisia eli alkiot
nkyvt kyttjlle suoraan.
Voisimme mritell vektorityypin alkiot mys yksityisiksi:
TYPE vektorityyppi
PRIVATE
REAL :: x
REAL :: y
REAL :: z
Tllin moduulia kyttv ohjelma ei voi viitata alkioihin suoraan. Tst seuraa mys se, ett tarvittaessa voimme vaihtaa tyypin mrittelyn ja moduulin toteutuksen toiseksi ilman, ett moduulia kyttvi ohjelmia tarvitsisi
muuttaa. Tyypin alkioista osa ei voi olla julkisia ja osa yksityisi, vaan joko
kaikki ovat julkisia tai kaikki yksityisi.
10.5 Esimerkki: vektorimoduulin jatkokehittely

Jos mrittelemme vektorityypin alkiot yksityisiksi, tarvitsemme moduuliin
vektorin alustavan funktion (seuraavassa vektori). Tyyppirakenteen alustinta ei voi kytt thn tarkoitukseen, koska emme ne vektorityypin sisist toteutusta.
FUNCTION vektori(x, y, z) RESULT(uusi)
! Funktio palauttaa arvonaan vektorin, jonka
! komponenttien arvot on annettu argumentteina
IMPLICIT NONE
REAL :: x, y, z
TYPE(vektorityyppi) :: uusi
160
Fortran 95/2003
uusi % x =
uusi % y =
uusi % z =
END FUNCTION
x
y
z
vektori
Lisksi tarvitsemme vektorin komponentit palauttavan funktion. Funktio

voisi sijoittaa komponenttien arvot taulukkoon ja palauttaa tmn taulukon arvonaan:
FUNCTION komponentit(vektori) RESULT(tulostaulukko)
! Funktio palauttaa vektorin komponenttien
! arvot tulostaulukossa
IMPLICIT NONE
TYPE(vektorityyppi) :: vektori
REAL, DIMENSION(3) :: tulostaulukko
tulostaulukko(1) = vektori % x
tulostaulukko(2) = vektori % y
tulostaulukko(3) = vektori % z
END FUNCTION komponentit
Moduulia vektorilaskenta voisi kytt nyt seuraavaan tapaan:

PROGRAM vektoritesti
USE vektorilaskenta
IMPLICIT NONE
TYPE(vektorityyppi) :: u, v, w
REAL :: k, pituus
u = vektori(1.0,0.0,0.0)
v = vektori(-1.0,1.0,1.0)
w = ristitulo(u,v)
k = pistetulo(u,v)
pituus = ABS(u)
WRITE(*,form) Vektori u: , komponentit(u)
WRITE(*,form) Vektori v: , komponentit(v)
WRITE(*,form) Vektorin u pituus: , pituus
WRITE(*,form) Vektoreiden u ja v ristitulo: , &
komponentit(w)
WRITE(*,form) Vektoreiden u ja v pistetulo: , k
END PROGRAM
Vektorin arvo mrtn kyttmll funktiota vektori ja vektorin komponentit saadaan selville funktiolla komponentit.
Voisimme laajentaa vektorityypin mrittely viel esimerkiksi siten, ett
se sislt tiedon koordinaattisysteemist, jossa vektorin komponentit on
esitetty:
TYPE vektorityyppi
PRIVATE
REAL :: x, y, z
TYPE(koordinaatisto) :: nykykoordinaatisto
161
Voisimme mys laajentaa vektorityypin ksittelemn n-ulotteisen avaruuden vektoreita, jolloin vektorin komponentit kannattaisi alunperinkin esitt
taulukkona:
TYPE vektorityyppi
PRIVATE
INTEGER :: n
REAL DIMENSION(:), POINTER :: komponentit
TYPE(koordinaatisto) :: nykykoordinaatisto
Vektorin alustavan proseduurin tehtviin kuuluu nyt mys varata komponenteille tarpeellinen mr tilaa. Dynaamisesta tilanvarauksesta kerrotaan
kappaleessa 11.11 (sivu 178) ja POINTER-mreell luoduista osoitinmuuttujista kappaleessa 11.13 (sivu 183).
10.6 Yhteenveto
Voit huomattavasti selkeytt ohjelmaa tehtvn sopivalla tietotyypin valinnalla. Tm samalla helpottaa ratkaisualgoritmin toteutusta. Yhdistmll rakenteiset tietotyypit ja moduulit voit luoda abstrakteja tietotyyppej
sek piilottaa toteutuksen yksityiskohdat kyttjlt, jonka ei nit yleens
tarvitse tiet.
Tyyppimrittely tehdn seuraavasti:
TYPE [, julkisuus ::] nimi
muuttujamrittelyt
END TYPE nimi
Rakenteista tietotyyppi kytetn seuraavasti:

TYPE(nimi) :: muuttuja
Tyypin alkioihin viitataan prosenttimerkin avulla:

nimi % komponentti
Tyyppimrittely luo rakenteen alustimen, jonka nimi on sama kuin tyypinkin. Alustinta kytetn antamaan rakenteisen tietotyypin muuttujalle
arvo:
muuttuja = tyyppi(arvo1,...,arvon)
Harjoitustehtvi
1. Laske vektorimoduulilla pistetulo vektoreista, joista toinen on kahden
vektorin ristitulo ja toinen jompi kumpi alkuperisist vektoreista. Mit
saat tulokseksi? Miksi?
Kirjoita vektorikolmitulon laskeva funktio, jonka otsikkorivi on
162
Fortran 95/2003
FUNCTION kolmitulo(v1, v2, v3) RESULT(a)
2. Kyt hyvksi jo mriteltyj operaatioita vektorimoduulissa ja lis

moduuliin tietotyyppi
TYPE kolmiotyyppi
Mrittele funktio normaali(k), joka laskee kolmion k yksikknormaalin. Vihje: muodosta vektorit v1 = t2-t1 ja v2 = t3-t1, miss suureet
t1,t2 ja t3 ovat kolmion krkipisteiden paikkavektorit ja kyt hyvksesi edellisen harjoitustehtvn tulosta. Onko normaali mielestsi yksiksitteinen?
Mrittele mys kolmion pinta-alan laskeva funktio pinta_ala(k).
3. Lis vektorimoduuliin operaatio, joka tarkistaa, ovatko kaksi vektoria
likimain samat. Kyt tss operaattorin == ylilatausta. (Likimrinen
yhtsuuruus mritelln tehtvss 9 sivulla 65.)
4. Laajenna kolmiotyypin mrittely ksittmn yleinen tasomonikulmio.
5. Lis vektorimoduuliin operaatiot, joka muuntavat vektorin komponentit karteesisesta koordinaatistosta pallokoordinaatistoon ja pinvastoin.
Niden funktioiden otsikkolauseet ovat
FUNCTION vektori_pallo(r, theta, phi) RESULT(vektori)
ja
FUNCTION komponentit_pallo(vektori) RESULT(tulostaulukko)
Koska moduulin sisinen esitysmuoto on karteesinen, funktioiden tytyy tehd tarpeelliset muunnokset. Muunnos karteesiseen koordinaatistoon tapahtuu kaavoilla
x = r sin cos ,
y = r sin sin ,
z = r cos .
6. Mrittele aliohjelma vaihda, joka vaihtaa kahden vektorin arvot keskenn:
CALL vaihda(v1,v2)
7. Mrittele rakenteinen tyyppi, joka voi tallettaa syntymajan seuraavassa muodossa:

21 01 1990
Siis rakenteinen tyyppi sislt kolme kokonaislukua, joilla on eri KINDarvot: SELECTED_INT_KIND(2) ja SELECTED_INT_KIND(4).
8. Lis edellisen harjoituksen rakenteiseen tyyppiin kentt nime varten.
9. Kirjoita funktio, joka palauttaa merkkijonossa nimen ja pivmrn
seuraavassa muodossa:
Jaska Jokunen (01.01.1999)
163
Kyt edellisess tehtvss luotua rakenteista tyyppi.

10. Mrittele operaattori .d., joka laskee kahden vektorin ptepisteiden
etisyyden toisistaan:
dist = u .d. v
Kyt mrittelyss kaavaa ABS(u-v). Huomaa, ett ABS-operaation toteuttava funktio vektorinormi (sivu 157) tuottaa ylivuodon, jos vektorin komponentit ovat lhell ylivuototasoa, vaikka tulos olisikin esitettviss liukulukuna. Esimerkin ongelmasta tarjoaa lauseke
ABS(vektori(a,a,a))
kun a = HUGE(1.0)/10. Korjaa funktion mrittely.

11. Mrittele pistetulo-operaattori .dot., jota kytetn seuraavasti:
s = u .dot. v
Mrittele mys ristitulo-operaattori .cross..

12. Mrittele funktio, joka laskee kahden vektorin vlisen kulman kaavalla

v w
= arccos
.
|v||w|
13. Mrittele kertolaskuoperaatio v = n*u miss n on skalaarityyppi REAL
tai INTEGER, ja muuttujat u ja v ovat vektorityyppi. Operaatiossa skaalataan vektorin alkiot annetulla kertoimella.
14. Esittelimme kappaleessa 3.12 (sivu 33) oppilaiden nimien ja arvosanojen tallentamiseen sopivan rakenteisen tyypin kurssilainen. Mrittele moduuli, jossa on tmn rakenteisen tyypin ksittelyyn tarvittavia
operaatioita. Mrittele oppilastietojen lukuja tulostusoperaatiot sek
arvosanojen keskiarvon laskemiseen soveltuva proseduuri.
164
Fortran 95/2003
11
Taulukot ja
osoitinmuuttujat
Esittelemme tss luvussa Fortran 95 -kielen taulukkoja osoitinmuuttujien

mrittelyn ja kyttmahdollisuudet. Lisksi kerromme ajonaikaisesta eli
dynaamisesta muistitilan varaamisesta.
11.1
Taulukoiden mrittely ja kytt
Taulukko (array) mritelln kertomalla kntjlle taulukon alkioiden

tyyppi, taulukon ulottuvuuksien mr (rank) sek mahdollisesti ulottuvuuksien koot eli taulukon muoto (shape). Lisksi mrittelyss voi antaa
joukon erilaisia mreit, kuten onko taulukko dynaamisesti varattavissa
tai voiko se olla kohteena osoitinmuuttujalle.
Tavallisesti taulukkomuuttuja mritelln joko antamalla tyyppimrittelyn jlkeen mre DIMENSION tai kirjoittamalla taulukon koko taulukon nimen pern. Esimerkiksi lausekkeet
REAL, DIMENSION(0:100,-50:50,10:110) :: x
REAL :: y(101,101,101)
mrittelevt molemmat kolmiulotteisen taulukon. Alkioita on kummassakin taulukossa 101 101 101. Tllainen taulukkomrittely on Fortran 95
-standardin kielell tunnetun muotoinen taulukko (explicit-shape array). Mrittelyst voi halutessaan jtt indeksien alarajat pois, jolloin nm oletetaan ykksiksi. Esimerkiksi reaalilukutaulukon mrittely on siis yleisemmin
muotoa
REAL, DIMENSION(ala1:yla1,ala2:yla2,...,alaN :ylaN ) :: x
tai muotoa
REAL :: x(ala1:yla1,ala2:yla2,...,alaN :ylaN )
Suurin taulukoiden indeksien eli ulottuvuuksien mr Fortran 95 -standardissa on seitsemn.

Seuraavassa ohjelmassa taulukoimme funktion sin x arvot vlilt [0, ] taulukkoon x:
11. Taulukot ja osoitinmuuttujat
165
PROGRAM taulukointi
IMPLICIT NONE
INTEGER :: i
REAL, DIMENSION(n) :: x
REAL :: pi
pi = 2*ACOS(0.0)
DO i = 1, n
x(i) = SIN(pi*(i-1.0)/(n-1.0))
END DO
WRITE(*,(A)) sin(x) =
WRITE(*,(5(F11.7))) x
END PROGRAM taulukointi

sin(x) =
0.0000000
0.1580014
...
0.1265922
0.0317279
0.1892512
0.0634239
0.2203106
0.0950560
0.2511480
0.1265925
0.2817326
0.0950560
0.0634239
0.0317279 -0.0000001
Dynaamisesti varattavan taulukon (dynamic array) kokoa ei kerrota mrittelyvaiheessa, vaan sek ala- ett ylrajat jtetn auki. Mrittelyss kytetn joko mrett ALLOCATABLE tai myhemmin esiteltv POINTERmrett. Esimerkiksi lause
REAL, DIMENSION(:,:,:), ALLOCATABLE :: x
mrittelee kolmiulotteisen taulukon, jonka kokoa ei ole mritelty. Mrittelyss kerrotaan, ett taulukko on kolmiulotteinen sek dynaamisesti
varattavissa. Tllaista taulukkoa kutsutaan mukautuvan muotoiseksi taulukoksi (deferred-shape array). Dynaamisesta muistin varauksesta kerrotaan
enemmn kappaleessa 11.11 (sivu 178).
Proseduureissa voi taulukoille varata tilaa mys suoraan muuttujamrittelyss automaattisten taulukoiden (automatic array) avulla:
SUBROUTINE ali(n)
IMPLICIT NONE
INTEGER :: n
jne.
END SUBROUTINE ali
Voit antaa taulukoille mys PARAMETER-mreen eli mritell vakiotaulukon:

INTEGER, DIMENSION(3), PARAMETER :: luvut = (/ 1,2,3 /)
166
Fortran 95/2003
11.2
Taulukon alkioiden ksittely
Taulukon alkioihin viitataan antamalla taulukon nimen perss sulkeissa

taulukon alkion indeksi(t). Seuraavassa ohjelmassa sijoitetaan ensin taulukon x kymmenenteen alkioon luku 0.0. Tmn jlkeen alustetaan taulukon
y alkioiden arvoksi 1.0.
PROGRAM silmukka
IMPLICIT NONE
REAL, DIMENSION(n,n,n) :: y
INTEGER :: i, j, k
x(n) = 0.0
DO i = 1, n
DO j = 1, n
DO k = 1, n
y(i,j,k) = 1.0
END DO
END DO
END DO
END PROGRAM silmukka
Jlkimmisen operaation voisi tehd helpommin taulukko-operaatioiden avulla eli yksinkertaisesti asettamalla:
y = 1.0
Taulukko-operaatioista kerrotaan kappaleessa 11.8 (sivu 174).

Taulukosta voi valita osan antamalla taulukon indeksit muodossa
x(alku:loppu:lisys)
Seuraava esimerkki vaihtaa taulukon x ensimmisen kymmenen alkion jrjestyksen keskenn:

REAL, DIMENSION(10) :: x
x(1:10) = x(10:1:-1)
Lausekkeen oikea puoli suoritetaan ensin, jolloin kntj tarvittaessa varaa

tilapisen muistitilan tulokselle, mink jlkeen tulos sijoitetaan vasemmalla puolella annettuun muuttujaan. Indeksien alku- tai loppurajat voi jtt
syntaksista pois, jolloin rajat otetaan taulukon mrittelyst. Edellinen taulukkosyntaksi ei siis ole sama asia kuin silmukka
DO i = 1, 10
x(i) = x(11-i)
END DO
Selit miksi!
Seuraava esimerkki lis kahden vlein taulukon x alkiot yhdest kymmeneen taulukon y alkioihin:
REAL, DIMENSION(5) :: y
167
y = y + x(::2)
Samaan tapaan voidaan valita osa useampiulotteisesta taulukosta. Mrittelemme aluksi taulukon
REAL, DIMENSION(5,8) :: a
Tllin lausekkeen
a(2:5:2, 4:6)
arvo on taulukko, jonka koko on 2 3 ja joka koostuu taulukon a riveist 2

ja 4 sek sarakkeista 4, 5 ja 6. Seuraavassa on merkill esitetty taulukosta
a valitut alkiot:
1
1
2
3
4
5
Taulukkoa voi mys indeksoida kokonaislukuvektorilla eli yksiulotteisella

taulukolla. Seuraavassa sijoitamme taulukkoon y taulukon x alkiot 1, 1, 2, 5
ja 9.
INTEGER, DIMENSION(5) :: i
REAL, DIMENSION(10) :: x, y
i = (/1,1,2,5,9/)
y(1:5) = x(i)
Sijoitusoperaatiota on havainnollistettu kuvassa 11.1.
x(1) x(2) x(3) . . . x(9) x(10)
1 1 2 5 9
x(i)
x(1) x(1) x(2) x(5) x(9)
y(1) y(2) y(3) y(4) y(5)
Kuva 11.1: Taulukon indeksointi kokonaislukuvektorilla.
Huomaa, ett taulukon x ensimminen alkio sijoitetaan sek taulukon y ensimmiseen ett toiseen alkioon. Fortran 95 -standardi kielt sijoituksen
toisin pin: samassa lausekkeessa ei voi sijoittaa kahteen kertaan arvoa samalle indeksille. Toisin sanoen lauseke
y(i) = x(1:5)
168
Fortran 95/2003
on kielletty yll annetuille vektorin i arvoille. Jos samoja arvoja ei esiinny

indeksivektorissa, taulukkoa voi kyll indeksoida vektorilla mys sijoituslausekkeen vasemmalla puolella.
11.3
Taulukkoalustin
Kytimme edell taulukkoalustinta (array constructor), jonka muotoja ovat

esimerkiksi
x(1:3) = (/ 1.0, 2.5, 3.0 /)
x(1:n) = (/ (SIN(pi*i/(n-1.0)), i = 0, n-1) /)
Taulukon alustin siis mritelln sulkeissa (/ . . . /). Jlkimmisen sijoituslauseen oikealla puolella on niin sanottu toistolista (implied do list),
joka toimii kuten tavallinenkin DO-silmukka. Toistolista on sulkujen sisll, ja indeksimuuttujan mrittely tulee silmukan sislln jlkeen pilkulla
erotettuna:
(SIN(pi*i/(n-1.0)), i = 0, n-1)
Toistolista on taulukon alustuksessa samassa asemassa kuin muutkin alustuslausekkeen osat. Esimerkiksi lauseke
(/ 0, (i, i = 1,5), 1 /)
tuottaa taulukon, jonka alkiot ovat

0 1 2 3 4 5 1
Rakenteen
(/ 0, (1, i = 1,4), (2, i = 1,3) /)
tuottamat arvot ovat puolestaan

0 1 1 1 1 2 2 2
Taulukkoalustimen tulos on aina yksiulotteinen taulukko eli vektori. Jos

haluat sijoittaa arvot useampiulotteiseen taulukkoon alustimen avulla, on
kytettv RESHAPE-funktiota. Alla olevassa esimerkiss sijoitamme kaksiulotteisen taulukon x alkioihin (1:2,1:3) arvot yhdest kuuteen taulukkoalustimen avulla:
x(1:2,1:3) = RESHAPE( (/ 1, 2, 3, 4, 5, 6 /), (/ 2, 3 /) )
RESHAPE-funktio palauttaa taulukon, jonka arvot on annettu ensimmisess

argumentissa. Tmn argumentin tulee olla yksiulotteinen taulukko. Palautettavan taulukon muoto mrytyy funktion toisen argumentin mukaan.
Edellisess esimerkiss RESHAPE-funktio tuottaa 2 3 -matriisin. Sijoituslauseen toimintaa on havainnollistettu kuvassa 11.2.
169
x(1,1) = 1
x(1,2) = 3
x(1,3) = 5
x(2,1) = 2
x(2,2) = 4
x(2,3) = 6
Kuva 11.2: Taulukon alkiojrjestys.
11.4
Taulukon alkioiden jrjestys
Fortran-standardi ei mr taulukon alkioiden talletusjrjestyst muistissa, vaan tm on jtetty kntjn toteuttajan tehtvksi. Taulukko-operaatioille on kyllkin mritelty taulukoiden alkiojrjestys (array element order),
joka on sama kuin FORTRAN 77 -standardissakin. Alkiojrjestys on mrtty siten, ett taulukon ensimmist indeksi vastaavat alkiot ovat jrjestyksess ensin, toista indeksi vastaavat alkiot tmn jlkeen, sitten kolmatta
jne. Matriisille alkioiden ksittelyjrjestys on siten sarakkeittain kuten
matematiikassa yleisesti ja pinvastoin kuin C-kieless.
Edellisen esimerkin alkiot tulivat siis talletetuksi taulukkoon x seuraavassa
alkiojrjestyksess:
x(1,1)
x(2,1)
x(1,2)
x(2,2)
x(1,3)
x(2,3)
11.5
=
=
=
=
=
=
1
2
3
4
5
6
Esimerkki: funktion arvojen talletus

taulukkoon
Taulukoidaan jlleen funktio sin x. Tll kertaa kysytn kyttjlt taulukoitavien pisteiden mr vlilt [0, ]. Taulukolle varataan dynaamisesti
muistia, ja funktion arvot tulostetaan ptteelle.
PROGRAM trigo
IMPLICIT NONE
REAL(KIND=reaali), DIMENSION(:), ALLOCATABLE :: x
REAL(KIND=reaali), PARAMETER :: &
pi = 3.141592653589793_reaali
INTEGER :: i, n, allocstat
WRITE(*,(A),ADVANCE=no) Anna n:
170
Fortran 95/2003
READ(*,*) n
IF (n > 0) THEN
ALLOCATE(x(n), STAT = allocstat)
IF ( allocstat /= 0 ) STOP
ELSE
STOP n <= 0!
END IF
x = (/ (i, i = 0, n-1) /)
x = SIN(pi*x/(n-1))
WRITE(*,(A)) sin(x) =
WRITE(*,(5(F10.7))) x
END PROGRAM trigo
Ohjelman kytt nytt tlt:

Anna n: 12
sin(x) =
0.0000000 0.2817326 0.5406408 0.7557496 0.9096320
0.9898214 0.9898214 0.9096320 0.7557496 0.5406408
0.2817326 0.0000000
11.6
Taulukoiden vlitys aliohjelmiin

Seuraava ohjelma laskee funktion f (x, y) = sin x 2 + y 2 kuvaajan taulukkoon z. Funktion arvot lasketaan aliohjelmassa f. Argumenttina vlitetn
pisteet, joissa funktio evaluoidaan, sek tulostaulukko. Aliohjelma tarkistaa lisksi, ett taulukot ovat todella samanmuotoisia, jotta operaatio olisi
mritelty.
PROGRAM taulukko
IMPLICIT NONE
INTEGER,PARAMETER :: n = 5
REAL, DIMENSION(n) :: t
REAL, DIMENSION(n,n) :: x, y, z
INTEGER :: i
t = (/ (10.0*i/(n-1)-5.0, i = 0, n-1) /)
DO i = 1,n
x(i,1:n) = t
y(1:n,i) = t
END DO
CALL f(x,y,z)
WRITE(*,*) z
CONTAINS
SUBROUTINE f(x,y,z)
IMPLICIT NONE
REAL, DIMENSION(:,:) :: x, y, z
IF ( ANY(SHAPE(x) /= SHAPE(y)) .OR. &
ANY(SHAPE(x) /= SHAPE(z)) ) THEN
171
WRITE(*,*) Argumentit eivt ole samanmuotoisia

STOP
ELSE
z = SIN(SQRT(x**2 + y**2))
END IF
END SUBROUTINE f
END PROGRAM taulukko
Funktion f kyttm standardifunktio SHAPE palauttaa arvonaan muuttujan muodon. Kaksiulotteisen taulukon muoto on rivien ja sarakkeiden lukumr. Standardifunktio ANY palauttaa tiedon siit, onko sille argumenttina
annetun loogisen taulukon arvoista mikn tosi.
Aliohjelman mrittelyss voi muodollisena argumenttina olla kolme erityyppist taulukkomrittely. Ensimminen nist on oletetun muotoinen
taulukko (assumed-shape array):
REAL, DIMENSION(ala1:,ala2:,ala3:) :: x
Taulukon varsinainen muoto mrytyy aliohjelmaa kutsuttaessa todellisen argumentin mukaan. Alarajat voi halutessaan jtt pois mrittelyst, jolloin ne oletetaan ykksiksi. Tss taulukkomrittelyss ei voi kytt
ALLOCATABLE-mrett. Oletetun muotoista taulukkomrittely kytettess proseduurin kutsumuodon on oltava tunnettu sek muodollisen ja todellisen parametrin tyyppien, lajiparametrien ja taulukkojen indeksien mrien
tytyy kaikkien olla samat.
Toinen taulukkoargumenttien kytttapa on tunnetun muotoinen taulukko
(explicit-shape array) eli taulukkomrittely, jossa taulukon muoto on kokonaan mrtty. Toisin kuin oletetun muotoiselle taulukolle, muodollisen ja
todellisen argumentin dimensioiden mrn ei tarvitse olla samat. Seuraavassa esimerkiss pohjelmassa mritelty kaksiulotteista taulukko ksitelln sek yksiulotteisena aliohjelmassa ali_1 ett kolmiulotteisena aliohjelmassa ali_3.
PROGRAM tunnettu_muoto
IMPLICIT NONE
REAL, DIMENSION(n,n) :: taul = 0.0
CALL ali_1(taul,n)
WRITE (*,(5(F8.3))) taul(3,:)
CALL ali_3(taul,n)
WRITE (*,(5(F8.3))) taul(3,:)
CONTAINS
SUBROUTINE ali_1(taul,n)
IMPLICIT NONE
INTEGER :: n
REAL, DIMENSION(n*n) :: taul
taul(8:20) = -1.0
END SUBROUTINE ali_1
SUBROUTINE ali_3(taul,n)
IMPLICIT NONE
INTEGER :: n
REAL, DIMENSION(n,n/2,2) :: taul
172
Fortran 95/2003
taul(3,:,:) = 1.0
END SUBROUTINE ali_3
END PROGRAM tunnettu_muoto
Kun knnmme ja ajamme ohjelman, tulostus nytt seuraavalta:

0.000
1.000
-1.000
1.000
-1.000
1.000
-1.000
1.000
0.000
0.000
Tss sijoitimme arvon 1 yksiulotteisen taulukon alkioihin 8, 9, . . . , 20. Kun

tulostimme vastaavan kaksiulotteisen taulukon kolmannen rivin, huomasimme alkioiden 2, 3 ja 4 muuttaneen arvoaan. Kun sijoitimme kolmiulotteiseen taulukkoon arvoja, muuttuivat tietenkin mys vastaavat alkuperisen
taulukon arvot.
Tunnetun muotoisten taulukkojen kyttminen on riskialtista, ja kaikki tarkistukset ovat ohjelmoijan vastuulla. Muista siis varmistaa, ett koodi tekee,
mit haluat sen tekevn.
Jos taulukon osia vlitetn proseduurille, jonka muodollinen argumentti
on mritelty tunnetun muotoisena taulukkona ja jonka dimensiot mahdollisesti eivt ole samat kuin taulukon mrittelyss kutsuvassa ohjelmassa,
osa taulukosta saatetaan joutua kopioimaan vliaikaiseen muuttujaan proseduuriin mentess ja takaisin alkuperiseen taulukkoon proseduurista palattaessa. Kopiointia ei tarvita, jos muodollinen argumentti on mritelty
oletetun muotoiseksi taulukoksi. Tllin ohjelma on luultavasti tehokkaampi.
Eriulotteisten taulukkojen alkioiden vastaavuudet mrytyvt Fortranin alkiojrjestyksen perusteella. Esimerkiksi kaksiulotteisen taulukon alkiot ovat
muistissa perkkin sarakkeittain (kuva 11.2 sivulla 169). Muistisntn voi
kytt lausetta ensimminen indeksi muuttuu nopeimmin.
Tunnetun muotoiselle taulukolle ei voi tietenkn kytt mreit POINTER
tai ALLOCATABLE, eik niille siis voi varata tilaa aliohjelmassa, vaan tilanvaraus on tytynyt tehd aikaisemmin.
Kolmas muodollisena argumenttina annetun taulukon mrittely on oletetun
kokoinen taulukko (assumed-size array):
REAL, DIMENSION(n1,n2,*), :: x
Tss taulukon koko jtetn ilmoittamatta viimeisen indeksin osalta. Tm

muoto on jnne FORTRAN 77 -standardista eik ole suositeltava.
Proseduuriin voi vlitt mys taulukon osan:
PROGRAM taulukko_pala
IMPLICIT NONE
REAL, DIMENSION(10) :: a = 1.0, b = -1.0
INTRINSIC SIN
b(2:9) = SIN(a(2:9))
END PROGRAM taulukko_pala
Taulukon osan voi vlitt mys ulkoiseen proseduuriin, kunhan samalla

vlitt taulukon koon:
173
PROGRAM taulukko_pala_2
IMPLICIT NONE
REAL, DIMENSION(n) :: a = 1.0, b = -1.0
EXTERNAL ali
CALL ali(a(1:n:2), n/2, b(1:n/2), n/2)
WRITE (*,(6(F8.3))) a, b
END PROGRAM taulukko_pala_2
SUBROUTINE ali(t1, m, t2, n)
IMPLICIT NONE
INTEGER :: m, n
REAL :: t1(m), t2(n)
t1 = 2.0
t2 = 4.0
END SUBROUTINE ali
Tss vlitimme ulkoiseen funktioon ali joka toisen alkion taulukosta a ja

kolme ensimmist alkiota taulukosta b. Ohjelma tulostaa seuraavaa:
2.000
4.000
11.7
1.000
4.000
2.000
4.000
1.000
-1.000
2.000
-1.000
1.000
-1.000
Taulukkoarvoiset funktiot
Funktiot voivat olla mys taulukkoarvoisia. Tm saadaan aikaiseksi mrittelemll RESULT-lausekkeessa annettu muuttuja taulukoksi (jonka tytyy
olla tunnetun muotoinen). Seuraavassa on tst esimerkki:
PROGRAM taulukkofunktio
IMPLICIT NONE
REAL, DIMENSION(n,n) :: x, y
INTEGER :: i
t = (/ (10.0*i/(n-1)-5.0, i = 0, n-1) /)
DO i = 1,n
x(i,1:n) = t
y(1:n,i) = t
END DO
WRITE(*,*) f(x,y)
CONTAINS
FUNCTION f(x,y) RESULT(z)
IMPLICIT NONE
REAL, DIMENSION(:,:) :: x,y
REAL, DIMENSION(SIZE(x,1),SIZE(x,2)) :: z
IF ( ANY(SHAPE(x) /= SHAPE(y)) ) THEN
WRITE(*,*) Argumentit eivt ole samanmuotoisia
STOP
174
Fortran 95/2003
ELSE
z = SIN(SQRT(x**2 + y**2))
END IF
END FUNCTION f
END PROGRAM taulukkofunktio
Funktio f palauttaa arvonaan kaksiulotteisen taulukon z, jonka koko saadaan selville standardifunktiolla SIZE. Funktio tarkastaa, ett taulukot x ja
y ovat saman kokoisia.
Palautettavan taulukon koko pit pysty laskemaan funktion argumenteista. Jos tm ei ole mahdollista, tulostaulukko pit palauttaa osoitinmuuttujia kytten, kuten kappaleen 11.11 funktiossa varaa (sivu 180).
11.8
Taulukkojen ksittely kokonaisuuksina
Fortran 95 -standardissa on paljon taulukko-operaatioita, joiden avulla taulukoita voidaan ksitell kokonaisuuksina. Tavalliset operaattorit (esimerkiksi +, , , sek loogiset operaattorit) suoritetaan taulukoille alkioittain. Mys useat Fortranin standardifunktiot (intrinsic function) ovat alkioittaisia, kuten esimerkiksi SIN, COS, SQRT jne. Lisksi kieless on taulukoiden
ksittelyyn tarkoitettuja sisisi apufunktioita, kuten matriisitulo (MATMUL)
sek matriisin alkioiden summan (SUM) tai tulon lasku (PROD).
Alla oleva aliohjelma laskee taulukon arvot sisltmien lukujen keskiarvon
ja keskihajonnan kytten taulukkofunktioita SIZE, SUM ja SQRT.
SUBROUTINE tilasto(arvot, keskiarvo, keskihajonta)
IMPLICIT NONE
REAL, DIMENSION(:), INTENT(IN) :: arvot
REAL, INTENT(OUT) :: keskiarvo, keskihajonta
REAL :: varianssi
INTEGER :: n
n = SIZE(arvot)
keskiarvo = SUM(arvot)/n
varianssi = SUM((arvot-keskiarvo)**2)/(n-1)
keskihajonta = SQRT(varianssi)
END SUBROUTINE tilasto
11.9
Taulukkojen ksittely standardifunktioilla
Taulukoiden ksittelyyn on Fortran 95 -standardissa useita standardifunktioita (katso mys lukua 13):
TRANSPOSE(a): Matriisin a transpoosi.
MATMUL(a,b): Matriisien a ja b matriisitulo.
175
DOT_PRODUCT(v1,v2): Vektoreiden v1 ja v2 sistulo.

SUM(array,dim,mask): Taulukon array alkioiden summa. Kuten edell mainittiin, niin argumentit dim ja mask ovat valinnaisia. Jos dim
on annettu, lasketaan vain tt indeksi vastaavat summat. Jos maskargumentti on annettu, kytetn taulukosta array summan laskemiseen vain alkioita, joiden indekseill taulukon mask vastaava arvo on
tosi.
PRODUCT(array,dim,mask): Taulukon alkioiden tulo.
MAXVAL(array,dim,mask), MINVAL(array,dim,mask): Taulukon alkioiden suurin ja pienin arvo.
MAXLOC(array,mask), MINLOC(array,mask): Suurimman ja pienimmn arvon paikat taulukossa.
COUNT(larray,dim): Tosien arvojen mr loogisessa taulukossa.
ANY(larray,dim): Tosi, jos jokin loogisen taulukon larray arvoista
on tosi.
ALL(larray,dim): Tosi, jos kaikki loogisen taulukon larray arvoista
ovat tosia.
LBOUND(array,dim): Taulukon indeksien alarajat.
UBOUND(array,dim): Taulukon indeksien ylrajat.
SHAPE(array): Taulukon muoto.
RESHAPE(vector,shape): Funktio palauttaa arvonaan taulukon, jonka
muoto on argumentin shape mrm. Taulukon arvot ovat perisin
argumentista vector.
SIZE(array,dim): Taulukon alkioiden lukumr.
ALLOCATED(array): Funktion arvo on tosi, jos dynaamisesti varattavalle taulukolle on varattu tilaa.
Seuraavassa esimerkiss alustamme taulukon matrix kyttmll funktiota
RESHAPE. Tmn jlkeen tulostamme matriisin alkioiden summan, matriisin
sarakesummat sek matriisin rivisummat.
PROGRAM matriisi
IMPLICIT NONE
REAL, DIMENSION(n,n) :: matrix
INTEGER :: i, j
matrix = RESHAPE( (/ ( (i-j, i = 1, n), j = 1, n) /), &
(/ n, n /) )
WRITE(*,form) Matriisin alkioiden summa on, SUM(matrix)
WRITE(*,form) Matriisin sarakesummat ovat, SUM(matrix,1)
WRITE(*,form) Matriisin rivisummat ovat, SUM(matrix,2)
END PROGRAM matriisi
Seuraavan esimerkin ensimminen suoritettava lauseke sijoittaa muuttujaan

n taulukon x positiivisten arvojen mrn. Toinen ja kolmas lauseke sijoittavat loogiseen muuttujaan l tiedon siit, onko joku taulukon alkioista negatiivinen.
176
Fortran 95/2003
REAL, DIMENSION(10,10) :: x
INTEGER :: n
LOGICAL :: l
n = COUNT( x > 0.0 )
l = ANY( x < 0.0 )
l = ALL( x >= 0.0 )
Rakenne WHERE(ehto) antaa mahdollisuuden valita taulukon alkioista ne,

joille halutaan tehd jokin operaatio. Seuraava ohjelmanosa asettaa taulukon x negatiiviset alkiot nolliksi.
WHERE( x < 0 )
x = 0
END WHERE
Saman asian voi tehd hiukan vhemmll kirjoittamisella kyttmll lausetta WHERE:
WHERE( x < 0 ) x = 0
WHERE-rakenteeseen voidaan liitt ELSEWHERE-haara:

WHERE( x /= 0.0 )
y = y / x
ELSEWHERE
y = 0.0
END WHERE
Fortran 95 -standardissa (toisin kuin Fortran 90:ss) useita WHERE-lauseita

voi olla siskkin:
WHERE (a >= 0)
WHERE (a /= 0)
a = 1.0/a
ELSEWHERE
a = HUGE(a)
ENDWHERE
ELSEWHERE
a = -HUGE(a)
ENDWHERE
Fortran sislt mys muutaman standardifunktion, joilla taulukoista voidaan eri tavoin valita haluttu joukko arvoja:
MERGE(truearray,falsearray,mask): Funktio palauttaa taulukon,
jonka alkiot valitaan argumentin mask mukaan siten, ett jos taulukon
mask vastinalkion arvo on tosi, alkio valitaan taulukosta truearray, ja
vastaavasti jos taulukon mask vastinalkion arvo on eptosi, alkio valitaan taulukosta falsearray.
SPREAD(array,dim,ncopies): Kopioidaan argumenttina annettua taulukkoa ncopies kertaa uuteen taulukkoon.
PACK(array,mask,vector): Tulostaulukkoon haetaan ne array-taulukon alkiot, joita vastaavat taulukon mask alkiot ovat tosia. Tulostaulukko on vektori (yksiulotteinen taulukko). Jos valinnainen argumentti
177
vector on annettu, tulostaulukon loppuun listn arvoja tst taulukosta, kunnes tulostaulukon koko on sama kuin taulukon vector.
UNPACK(vector,mask,array): Taulukon vector arvot sijoitetaan taulukon array paikalle siell, miss taulukon mask arvot ovat tosia.
CSHIFT(array,shift,dim): Siirretn taulukon alkioita argumentin
shift kertoma mr argumentin dim antamaan suuntaan. Taulukon
reunalta ulos menevt alkiot tulevat taulukon toiselta laidalta sisn.
EOSHIFT(array,shift,boundary,dim): Funktio toimii muuten samalla tavalla kuin funktio CSHIFT, paitsi ett taulukon rajalta ulos joutuvat
alkiot eivt kierr toiselle laidalle, vaan nm arvot otetaan valinnaisesta argumentista boundary (jos tt ei ole annettu, arvot asetetaan
nolliksi).
11.10
FORALL-rakenne
Fortran 95:een (mutta ei Fortran 90:een) sisltyy FORALL-lause ja -rakenne,

jotka laskevat joukon laskutoimituksia rinnakkain annetuilla indeksien arvoilla:
INTEGER :: i, j
REAL, DIMENSION(n, n) :: a
...
FORALL (i = 1:n:2, j = 1:n:2, a(i,j) > 0)
a(i,j) = i + j
END FORALL
FORALL (i = 1:n) a(i,i) = i**2
Seuraavassa on esimerkki siskkisist DO-silmukoista:

DO i = 1, n
DO j = 1, m
A(i,j) = i + j
END DO
END DO
Voimme esitt saman FORALL-lauseena ja -rakenteena:

FORALL (i = 1:n, j = 1:m) a(i,j) = i + j
FORALL (i = 1:n, j = 1:m)
a(i,j) = i + j
END FORALL
FORALL mahdollistaa mys vinojen taulukkolohkojen ksittelyn:

FORALL (i = 1:n) a(i,i) = b(i)
FORALL (i = 2:n) a(i,i-1) = c(i)
178
Fortran 95/2003
Tss sijoitimme taulukon a lvistjlle vektorin yksiulotteisen taulukon b

alkioita ja lvistjn alle vektorin c alkioita. Jos n = 5, edellisten FORALLlauseiden tulos nytt seuraavalta:
b(1)
c(2) b(2)
c(3) b(3)
.
a(1:n,1:n) =
c(4) b(4)

c(5) b(5)
Normaali taulukkosyntaksi poimii taulukoista suorakulmaisen lohkon. Esimerkkin mrittelemme taulukon
REAL, DIMENSION(5,8) :: y
Tllin lauseke y(2:5:2, 4:6) poimii taulukosta seuraavan 23 -kokoisen

lohkon:
1
2
3
4
5
FORALL-rakenteessa voi olla useampi lause:

FORALL (i = 2:n-1, j = 2:n-1)
a(i,j) = 0.25*(a(i+1,j) + a(i-1,j) + a(i,j+1) + a(i,j-1))
b(i,j) = 1.0/(a(i+1,j+1)
END FORALL
Kytettviss on mys ehdollinen FORALL-rakenne:

FORALL (i = 1:n, j = 1:m, a(i) < 9.0 .AND. b(j) < 9.0)
c(i,j) = a(i) + b(j)
END FORALL
11.11
Dynaaminen muistinvaraus
Taulukoille voidaan varata tilaa staattisen varauksen lisksi ohjelman suorituksen aikana, jolloin taulukon koko voidaan mrt esimerkiksi ohjelman
sytteiden mukaan. Dynaamisesti varattava taulukko tytyy ilmoittaa kntjlle mreell ALLOCATABLE tai vaihtoehtoisesti mreell POINTER. Mre POINTER mrittelee osoitinmuuttujan, joista kerrotaan enemmn kappaleessa 11.13 (sivu 183). Mys proseduurien automaattiset taulukot, joista on
kerrottu kappaleessa 11.1, ovat dynaamisesti varattavia taulukoita.
Joissain tilanteissa, kuten esimerkiksi omien tietotyyppien mrittelyss,
ALLOCATABLE-mrett ei voi kytt, vaan on kytettv POINTER-mrett.
Seuraavassa on esimerkki mreiden kytst:
179
REAL, DIMENSION(:,:), ALLOCATABLE :: x

REAL, DIMENSION(:), POINTER :: y
Taulukon koot siis jtetn kokonaan mrittelemtt, vain taulukon dimensioiden mr annetaan mrittelyss kyttmll symbolia :. Ajonaikainen
tilanvaraus tehdn ALLOCATE-lauseella seuraavasti:
INTEGER :: allocstat
ALLOCATE(x(-n:n,0:m), y(n), STAT=allocstat)
IF (allocstat /= 0) STOP
Varattavan taulukon muoto annetaan muuttujan nimen perss sulkeissa.

STAT-osassa mrtty kokonaislukumuuttuja allocstat saa arvon nolla,
jos varaus onnistuu, ja nollasta poikkeavan arvon, jos varaus eponnistuu.
Jos valinnaista STAT-osaa ei ole annettu, ohjelman suoritus pttyy muistin
varauksen syyst tai toisesta eponnistuessa.
DEALLOCATE-lauseella voidaan vapauttaa ALLOCATE-lauseessa taulukolle varattu tila. DEALLOCATE-lauseen syntaksi on
DEALLOCATE(x, STAT=deallocstat)
STAT-lausekkeessa mainittuun muuttujaan ptevt samat kommentit kuin

ALLOCATE-lauseen yhteydesskin.
Voimme selvitt ALLOCATED(x)-funktiolla, onko muuttujalle x varattu tilaa.
Voimme siis testata ohjelmassamme, onko taulukolle x jo varattu tilaa, ja
jos ei, niin tehd varauksen seuraavaan tapaan:
IF (.NOT. ALLOCATED(x)) ALLOCATE(...)
Proseduurin sisll paikalliseen muuttujaan varattu tila on yleens vapautettava ennen proseduurista poistumista: paikalliset muuttujat voivat, toteutuksesta riippuen, menett tilansa proseduurista poistuttaessa. Nm
muuttujat varataan yleens joka kerta uudestaan ohjelman yllpitmst
pinomuistista.
Tarvittaessa muuttujan saa kyllkin silyttmn arvonsa proseduurikutsujen vlill kyttmll SAVE-mrett. Fortran 95 -kieless, Fortran 90:st
poiketen, paikallisiin muuttujiin ALLOCATE-lauseella varattu tila vapautetaan
automaattisesti, jos nille ei ole annettu SAVE-mrett. Hyv tapa kuitenkin
on kytt eksplisiittisesti DEALLOCATE-lausetta.
Jos proseduuriin vlitetn POINTER-tyyppinen taulukko, joka varataan dynaamisesti, alkaa taulukon indeksointi samasta arvosta kuin vlitettvss
POINTER-taulukossa. Vertaamme POINTER- ja ALLOCATABLE-taulukkojen vlittmist eri tavalla mriteltyihin funktioihin:
PROGRAM ptr_testi
IMPLICIT NONE
REAL, DIMENSION(:), POINTER :: a
REAL, DIMENSION(:), ALLOCATABLE :: b
ALLOCATE (a(-1:1), b(-1:1))
WRITE (*,(A,5(I4))) Alarajat: , lb_1(a), lb_1(b), &
lb_2(a), lb_3(a), lb_3(b)
180
Fortran 95/2003
CONTAINS
INTEGER FUNCTION lb_1(x) RESULT(lb)
IMPLICIT NONE
REAL, DIMENSION(:) :: x
lb = LBOUND(x,1)
END FUNCTION lb_1
IMPLICIT NONE
REAL, DIMENSION(:), POINTER :: x
lb = LBOUND(x,1)
END FUNCTION lb_2
IMPLICIT NONE
REAL, DIMENSION(2:) :: x
lb = LBOUND(x,1)
END FUNCTION lb_3
END PROGRAM ptr_testi
Funktio LBOUND palauttaa indeksin alarajan. Ohjelma tulostaa seuraavaa:

Alarajat:
-1
Funktiossa lb_1 alaraja on oletusarvo eli 1. Funktioon lb_2 vlitetn osoitintaulukko, ja indeksointi alkaa esimerkiss 1:st. Funktiossa lb_3 on
puolestaan mritelty, ett indeksointi aloitetaan aina arvosta 2.
Jos proseduuri varaa muistia osoitinmuuttujaan (POINTER), varattu muistitila voidaan palauttaa kutsuvalle proseduurille, jolloin sen tehtvksi j
hoitaa mys muistitilan vapauttaminen.
Seuraavassa ohjelmassa funktio varaa palauttaa osoitinmuuttujan, jonka
voi sijoittaa toiseen osoitinmuuttujaan komennolla => (kappale 11.13 sivulla 183):
PROGRAM varaus
IMPLICIT NONE
REAL, DIMENSION(:), POINTER :: a
a => varaa(1000)
WRITE(*,*) Varatun taulukon koko=, SIZE(a)
DEALLOCATE(a)
CONTAINS
FUNCTION varaa(n) RESULT(p)
IMPLICIT NONE
INTEGER :: n
REAL, DIMENSION(:), POINTER :: p
INTEGER :: allocstat
ALLOCATE(p(n), STAT=allocstat)
IF (allocstat > 0) CALL varausvirhe(allocstat)
CONTAINS
SUBROUTINE varausvirhe
WRITE (*,*) Muistin varaus eponnistui,&
& paluukoodi:, allocstat
STOP
END SUBROUTINE varausvirhe
181
END FUNCTION varaa

END PROGRAM varaus
Seuraavassa on esimerkki dynaamisen muistinvarauksen kytst:

PROGRAM pisteparit_n
! Lasketaan odotusarvo n-ulotteisesta yksikkkuutiosta
! satunnaisesti valittujen pisteiden etisyydelle.
IMPLICIT NONE
REAL (KIND=reaali), DIMENSION(:,:), ALLOCATABLE :: a, b
REAL (KIND=reaali) :: t = 0.0, keskiarvo
INTEGER :: m, n, allocstat
WRITE (*,*) Anna dimensio ja pisteparien lkm:
READ (*,*) m, n
WRITE (*,*) Dimensio:, m, pistepareja:, n
IF (m > 0 .AND. n > 0) THEN
ALLOCATE(a(m,n), b(m,n), STAT=allocstat)
IF (allocstat > 0) CALL varausvirhe
t = SUM(SQRT(SUM((a-b)**2, DIM=1)))
keskiarvo = t/n
WRITE (*,*) Etisyyden keskiarvo:, keskiarvo
ELSE
WRITE (*,*) Lukumr tai dimensio negatiivinen!
END IF
CONTAINS
SUBROUTINE varausvirhe
WRITE (*,*) Muistin varaus eponnistui,&
& paluukoodi:, allocstat
STOP
END SUBROUTINE varausvirhe
END PROGRAM pisteparit_n
Seuraavassa on ohjelman kyttesimerkki:

Anna dimensio ja pisteparien lkm:
2 100000
Dimensio: 2 pistepareja: 100000
0.5211873481557983
Jos tehtvn dimensio tai pisteparien lukumr valitaan suureksi, tarvitaan edellisess ohjelmassa hyvin paljon keskusmuistia. Jos dimensio on
esimerkiksi 5 ja pistepareja on 100 000, varataan ohjelmassa muistitilaa
2 5 100 000 = 106 reaaliluvun verran. Jos reaaliluku vie tilaa esimerkiksi kahdeksan tavua, varataan ohjelmassa tss tapauksessa keskusmuistia
8 megatavua.
Fortran 95 vapauttaa automaattisesti proseduureissa varatut paikalliset dynaamiset taulukot:
SUBROUTINE testi(n)
IMPLICIT NONE
INTEGER :: n
182
Fortran 95/2003
REAL, ALLOCATABLE :: x(:)

ALLOCATE(x(n))
...
END SUBROUTINE testi
Siis lauseen ALLOCATE jlkeen ei en vlttmtt tarvita DEALLOCATE-ksky.
11.12
Esimerkki: Erastotheneen seula
Erastotheneen seula on klassinen algoritmi alkulukujen lytmiseksi. Vaikka nykyisin tunnetaan paljon tehokkaampiakin menetelmi, pystytn tll
menetelmll etsimn esimerkiksi miljoonaa pienemmt alkuluvut kohtalaisen nopeasti. Seula perustuu yksinkertaiseen ideaan: poistetaan lukutaulukosta ensin kahdella jaolliset luvut, sitten kolmella jaolliset luvut, sitten
viidell jaolliset luvut jne.
Kytmme Erastotheneen seulan toteuttamiseen taulukkosyntaksia ja dynaamista muistinvarausta. Ohjelma kysyy alkulukujen ylrajaa ja seuloo tmn jlkeen alkuluvut taulukkoon numerot.
PROGRAM Erastotheneen_seula
IMPLICIT NONE
INTEGER, PARAMETER :: iso = SELECTED_INT_KIND(9)
INTEGER(iso) :: max_nro
INTEGER(iso), DIMENSION(:), ALLOCATABLE :: numerot
INTEGER(iso) :: i, alku_lkm
INTEGER :: ok
WRITE (*,*) Syt alkulukujen ylraja:
READ (*,*) max_nro
IF (max_nro > 2) THEN
ALLOCATE (numerot(max_nro), STAT=ok)
IF (ok /= 0) THEN
WRITE (*,*) Muistinvaraus eponnistui!
STOP
END IF
! Taulukon alustus luvuilla 0, 2, 3, 4, ...
numerot = (/ 0, (i, i = 2, max_nro) /)
DO i = 2, FLOOR(SQRT(REAL(max_nro)))
IF (numerot(i) /= 0) THEN
numerot(2*i:max_nro:i) = 0
ENDIF
END DO
! Lasketaan alkulukujen lkm
alku_lkm = COUNT(numerot /= 0)
! Kertn alkuluvut taulukon alkuun
numerot(1:alku_lkm) = PACK(numerot, numerot /= 0)
! Tulostus
183
WRITE (*,(A,I10,A,I10)) Lysin , alku_lkm, &

kpl alkulukuja, jotka olivat <=, max_nro
WRITE (*,(5I10)) numerot(1:alku_lkm)
ELSE
WRITE (*,*) Ylrajan tytyy olla > 2!
END IF
END PROGRAM Erastotheneen_seula
Silmukassa
DO i = 2, FLOOR(SQRT(REAL(max_nro)))
ei tarvitse kyd lpi kaikkia lukuja maksimiarvoon max_nro asti, sill mak
simiarvon nelijuurta max_nro suuremmat luvut tulisivat muuten kyty
lpi kahteen kertaan.
Taulukko-operaatio COUNT laskee .TRUE.-arvojen lukumrn ja operaatio
PACK pakkaa taulukosta halutut alkiot.
Ohjelma tulostaa kaikki lydetyt alkuluvut, joten maksimiarvoksi ei kannata
sytt kovin suurta lukua:
% f90 seula.f90
% ./a.out
Syt alkulukujen ylraja:
100
Lysin
25 kpl alkulukuja, jotka olivat <=
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
100
Ohjelma tulostaa vain alkulukujen lukumrn, jos poistat lauseen (tai muutat sen huutomerkill kommentiksi)
WRITE (*,(5I10)) numerot(1:alku_lkm)
Seuraavassa kyttesimerkki:
Syt alkulukujen ylraja:
1000000
Lysin
78498 kpl alkulukuja, jotka olivat <=
1000000
Laskentaan menee aikaa korkeintaan muutama sekunti.
11.13
Osoitinmuuttujat
Osoitinmuuttujalla voidaan antaa jollekin muuttujalle, taulukon osalle tai

rakenteisen tietotyypin osalle toinen nimi eli alias. Toisaalta osoitinmuuttuja voidaan kohdistaa uuteen muistialueeseen, jolloin sit kytetn kuten
luvussa 11.11 ksiteltyj dynaamisesti varattavia taulukkoja. Osoitinmuuttuja mritelln antamalla mre POINTER.
184
Fortran 95/2003
Osoitinmuuttujien trkeimpi kytttarkoituksia ovat dynaamiset tietorakenteet kuten lista- ja puurakenteet sek muuttuvan mittaiset taulukot omissa tietotyypeiss.
Jotta osoitinmuuttujaa voitaisiin kytt, tytyy se ensin saada osoittamaan
johonkin muistitilaan. Uuden muistialueen varaaminen ja thn osoittaminen tehdn siis ALLOCATE-lauseella, mink jlkeen osoittimen kytt on
oleellisesti samanlaista kuin tavallisten muuttujienkin.
REAL, DIMENSION(:,:), POINTER ::
ALLOCATE (x(100,100))
x(3:6, 3:6) = 0.0
Toisaalta osoitinmuuttujan voi laittaa osoittamaan jo varattuun muistitilaan

osoitinsijoituksella (merkint =>).
REAL, POINTER :: osoitin
REAL, DIMENSION(10), TARGET :: taulukko
osoitin => taulukko(4)
Osoitinmuuttujan osoittamalle kohteelle tytyy muuttujamrittelyss antaa mre TARGET (tai kohteen tytyy olla toinen osoitin). Tmn lisksi
osoittimen ja kohteen alkioiden tyyppien tulee olla lajiparametri mukaan
lukien samat. Taulukoiden yhteydess taulukoiden ulottuvuuksien mrien
on oltava samat.
Kun osoitinmuuttuja on tavalla tai toisella saatu osoittamaan johonkin varattuun muistitilaan, se kyttytyy kuten tavallinenkin muuttuja. Arvon sijoittamiseksi osoitinmuuttujan kohteeseen kytetn tavallista sijoituslausetta.
Jos osoitinmuuttuja osoitin on alustettu kuten edell, niin lauseke
osoitin = 5
muuttaa taulukon taulukko neljnnen alkion arvoksi luvun 5.

Taulukkoon viittaavan osoitinmuuttujan mrittelyss ei voi kytt mrett ALLOCATABLE, vaan tm sisltyy mreeseen POINTER. Muista osoitintaulukoiden ja ALLOCATABLE-mreell mriteltyjen taulukoiden eroista
mainittakoon:
Omien tietotyyppien mrittelyiss ALLOCATABLE-mrett ei voi kytt, vaan tllin on kytettv POINTER mrett.
Funktio ei voi palauttaa arvonaan ALLOCATABLE-mreell mritelty
taulukkoa. Funktio voi palauttaa arvonaan taulukon, jolle on varattu
tilaa automaattisesti funktion mrittelyss. Esimerkiksi funktio
FUNCTION n_yksi(n) RESULT(a)
IMPLICIT NONE
INTEGER :: n
REAL, DIMENSION(n) :: a
a(1:n) = 1
END FUNCTION n_yksi
palauttaa arvonaan taulukon, jonka arvot on alustettu ykksiksi.

Funktio voi palauttaa mys POINTER-mreen avulla luotuja dynaamisia
taulukoita.
185
ALLOCATABLE-mrett ei voi kytt proseduurin muodolliselle parametrille, mutta POINTER-mrett voi kytt.
Seuraavassa esimerkiss osoitinmuuttujia kytetn eri tavoin. Aluksi mrittelemme muuttujat ja alustamme taulukon a:
REAL, DIMENSION(5), TARGET :: a
REAL, POINTER :: b, d
REAL, POINTER, DIMENSION(:) :: c
a = (/ (i, i = 1, 5) /)
Sijoitamme osoittimeen b taulukon a toisen alkion osoitteen:

b => a(2)
WRITE(*,*) b
WRITE-lauseen tulostus on
2.000000
Seuraavan lausekkeen jlkeen osoitinmuuttuja c on alias taulukon a alkioille

3 ja 5.
c => a(3:5:2)
WRITE(*,*) c
3.000000
5.000000
Edellisi osoitinmuuttujien b ja c kyttesimerkkej on havainnollistettu

kuvassa 11.3.
1 2 3 4 5
a
b
c
1 2
Kuva 11.3: Osoitinmuuttujien kyttesimerkki.
Kun sijoitamme osoitinmuuttujaan b jonkin arvon, muutamme osoittimen

kohteen arvoa:
b = 1
WRITE(*,*) a(2)
1.000000
POINTER-mreell mriteltyyn osoitinmuuttujaan voi varata muistitilaa

dynaamisesti:
ALLOCATE(c(5))
186
Fortran 95/2003
d => c(2)
d = 5
WRITE(*,*) c(2)
Lause d
Lause d
si luvun
tulostus
=> c(2) saa osoitinmuuttujan d osoittamaan muuttujaan c(2).

= 5 puolestaan asettaa muuttujan d osoittaman muuttujan arvok5, joten tss muutetaan alkion c(2) arvoa. Siten WRITE-lauseen
on
5.000000
Sijoitusoperaatioiden => ja = eron ymmrtminen on trke osoitinmuuttujia kytettess. Vr sijoituslause johtaa vaikeasti lydettviin virhetilanteisiin. Muistitilan varausta ja osoittimen d kytt on havainnollistettu
kuvassa 11.4.
1 2 3 4 5
c
d
Kuva 11.4: Osoitinmuuttujaan c on varattu tilaa dynaamisesti. Osoitinmuuttuja d
osoittaa taulukon c toiseen alkioon.
Taulukko-osoittimen alkioille ei voi yksitellen kytt osoitinsijoitusta, toisin sanoen taulukko-osoitinta ei voi osoituksessa indeksoida. Tmn rajoituksen voi kiert mrittelemll taulukon, jonka alkiot ovat itse mritelty toissijaista tietotyyppi. Tm toissijainen tietotyyppi koostuu puolestaan yhdest komponentista, joka on osoitinmuuttuja ensisijaiseen rakenteen sisltvn tietotyyppiin. Osoitinmuuttujien tllaista kytt selvent
luvun 14.7 sukupuuesimerkki sivulla 261.
Funktio ASSOCIATED(osoitin) palauttaa arvonaan tiedon siit, onko osoittimelle annettu jokin kohde. Tlle funktiolle ei kuitenkaan voi antaa argumenttina osoitinta, jota ei ole alustettu tavalla tai toisella. Ennen osoittimen kohdistamista se on epmrisess tilassa. Sit ei siis voi vlitt ASSOCIATEDlausekkeelle, jotta voisimme tarkistaa onko se kohdistettu. Tst ongelmasta
psemme lauseella NULLIFY(osoitin), joka alustaa osoittimen nollattuun
tilaan, muttei kohdista osoitinta mihinkn kohteeseen.
Fortran 95 sislt NULLIFY-lauseen lisksi funktion NULL(), jolla osoitinmuuttuja voidaan mys alustaa:
osoitin => NULL()
Funktiota NULL voi kytt muuttujamrittelyiss alustimena sek rakenteiden oletusarvojen mrityksiss, toisin kuin NULLIFY-lausetta.
Funktiokutsu ASSOCIATED(a,b) kertoo, osoittaako osoitinmuuttuja a kohteeseen b. Jos sek a ett b ovat osoitintyyppi, kertoo funktiokutsu, osoittavatko ne samaan kohteeseen.
11.14
187
Esimerkki: listarakenne
Tss luvussa teemme ohjelman, joka ksittelee linkitetty listaa. Listan alkiot ovat tss esimerkiss kaksi kokonaislukua: avain ja lkm. Mrittelemme listan siten, ett listtess listaan alkioita ne tallentuvat avaimen
mukaan suuruusjrjestyksess. Lisksi listassa on tieto siit, kuinka monta
kertaa kukin luku on talletettu listaan.
MODULE listamoduuli
IMPLICIT NONE
TYPE alkiotyyppi
INTEGER :: avain, lkm
END TYPE alkiotyyppi
TYPE listatyyppi
TYPE(alkiotyyppi) :: alkio
TYPE(listatyyppi), POINTER :: seuraava
END TYPE listatyyppi
CONTAINS
Aliohjelman lisaa mrittely.
END MODULE listamoduuli
Vaikka tyyppimrittelyss listatyyppi kytetn tyyppi itsen, on tm rakenne luvallinen: rakenteinen tyyppi voi sislt osoittimen omaan
tyyppiins.
Aliohjelma, joka lis alkion listaan, voitaisiin mritell seuraavasti:
SUBROUTINE lisaa(lista, luku)
! Listn kokonaisluku listaan, siten ett alkiot pysyvt
! avaimen mukaan kasvavassa jrjestyksess.
IMPLICIT NONE
TYPE(listatyyppi), POINTER :: lista
INTEGER :: luku
TYPE(listatyyppi), POINTER :: edellinen, uusi, nykyinen
nykyinen => lista
NULLIFY(edellinen)
DO WHILE( ASSOCIATED(nykyinen) )
IF ( luku > nykyinen % alkio % avain ) THEN
! Jos listtv luku on suurempi kuin listan
! nykyalkion avain mennn listassa eteenpin
edellinen => nykyinen
nykyinen => nykyinen % seuraava
ELSE IF ( nykyinen % alkio % avain == luku ) THEN
! Listassa on jo tm arvo
nykyinen % alkio % lkm = nykyinen % alkio % lkm + 1
EXIT
ELSE
! Oikea paikka lytyi. Listn listaan uusi alkio
ALLOCATE( uusi )
IF ( ASSOCIATED(edellinen) ) THEN
edellinen % seuraava => uusi
188
Fortran 95/2003
ELSE
lista => uusi
END IF
uusi % alkio % avain = luku
uusi % alkio % lkm = 1
uusi % seuraava => nykyinen
EXIT
END IF
END DO
! Jos lista tuli kyty kokonaisuudessaan lpi, uusi
! arvo kuuluu listan loppuun. Jos listaa ei alunperin
! ollut olemassa, luodaan se.
IF ( .NOT. ASSOCIATED(nykyinen) ) THEN
IF ( ASSOCIATED(edellinen) ) THEN
ALLOCATE(uusi)
edellinen % seuraava => uusi
ELSE
ALLOCATE( lista )
uusi => lista
END IF
uusi % alkio % avain = luku
uusi % alkio % lkm = 1
NULLIFY( uusi % seuraava )
END IF
END SUBROUTINE lisaa
Lista pttyy siis osoittimeen, jolle ASSOCIATED-funktio palauttaa arvon eptosi. Kun listaan luodaan uusi alkio, sen seuraaja tytyy alustaa NULLIFYfunktiolla
NULLIFY( uusi % seuraava )
Aliohjelmaa lisaa tytyy ensimmisell kerralla kutsua muuttujalla, joka

on alustettu NULLIFY-funktiolla. Kun lista on luotu, sen lpikynti jrjestyksess tuottaa luvut suuruusjrjestyksess pienimmst suurimpaan:
PROGRAM listatesti
USE listamoduuli
IMPLICIT NONE
TYPE(listatyyppi), POINTER :: lista
INTEGER :: i,n
REAL :: x
NULLIFY(lista)
DO i = 1,5
n = 10 * x
WRITE( *,* ) Lis: , n
CALL lisaa(lista,n)
END DO
WRITE(*,*) Listan sislt:
DO WHILE( ASSOCIATED(lista) )
WRITE(*,*) Alkio: ,lista % alkio % avain, &
Lukumr: ,lista % alkio % lkm
189
lista => lista % seuraava

END DO
END PROGRAM listatesti
Seuraavassa on ohjelman listatesti tuottama tulostus:

Lis:
Lis:
Lis:
Lis:
Lis:
1
9
8
4
4
Listan sislt:
Alkio:
Alkio:
Alkio:
Alkio:
1
4
8
9
Lukumr:
Lukumr:
Lukumr:
Lukumr:
1
2
1
1
Luvussa 14 (sivu 234) on esimerkkein osoitinmuuttujien kytst esitetty

binripuun ja sukupuun ksittely.
11.15
Yhteenveto
Taulukon mrittelyss kytetn mrett DIMENSION:

tyyppi, DIMENSION(indeksien rajat) :: muuttujien_nimet
Nin mritelty taulukko on tunnetun muotoinen taulukko.

Aliohjelmaan taulukoita vlitettess on (yksiulotteisen) taulukon mrittely
seuraavan nkinen:
tyyppi, DIMENSION([alaraja]:[ylraja]) :: muuttujan_nimi
Tm mrittely tuottaa ns. oletetun muotoisen taulukon.

Taulukoille ja osoitinmuuttujille voi varata tilaa dynaamisesti ohjelman suorituksen aikana. Dynaamisesti varattavan taulukon mrittely on seuraavaa
muotoa:
tyyppi, DIMENSION(:,[:,...,:]), ALLOCATABLE :: muuttujan_nimi
Tm on ns. mukautuvan muotoinen taulukko. Dynaaminen muistin varaus

tehdn funktiolla
ALLOCATE(muuttujan_nimi([alaraja:]ylraja] &
[, STAT=muuttujan_nimi])
Varatun muistitilan voi vapauttaa funktiolla

DEALLOCATE(muuttujan_nimi[, STAT=muuttujan_nimi])
Nollan kokoinen taulukko on luvallinen Fortranissa. Esimerkiksi sijoitus

x(1:0) = 3
190
Fortran 95/2003
ei tee mitn. Toisaalta taulukot x(1:0,1:2) ja x(1:0,1:3) eivt ole samanmuotoiset (conformable), koska ensimmisen taulukon koko on 0 2 ja
toisen 0 3.
Taulukkoa voi indeksoida kokonaislukuvakiolla, skalaarimuuttujalla tai kokonaislukuvektorilla sek rakenteella [alku][:loppu][:lisys].
Osoitinmuuttuja luodaan POINTER-mreell:
tyyppi, POINTER :: muuttujan nimi
Osoitinmuuttujan kohteena olevalle muuttujalle tulee antaa mre TARGET:

tyyppi, TARGET :: muuttujan nimi
Tmn lisksi osoittimen ja sen kohteen on oltava samaa tyyppi, sek taulukoiden osalta saman muotoisia.
Trke osoitinmuuttujien kyttkohde ovat dynaamiset tietorakenteet kuten listat (kappale 11.14 sivulla 187) ja puurakenteet. Binripuun toteutusta ksittelee kappale 14.6 sivulla 256 ja sukupuun toteutusta kappale 14.7
sivulla 261.
Harjoitustehtvi
1. Onko seuraava mrittely oikein?
REAL DIMENSION(1:3,2:3) :: aa
2. Mrittele kokonaislukutaulukko taulu, jossa on 3 rivi ja 4 saraketta.

3. Muunna seuraava ohjelma siten, ett siin kytetn DO-silmukoiden
sijaan taulukkosyntaksia.
PROGRAM taulukko
IMPLICIT NONE
REAL :: a
REAL, DIMENSION(n) :: b
REAL, DIMENSION(n,n) :: c, d
INTEGER :: i, j
CALL RANDOM_NUMBER(c)
WRITE (*,*) b
DO i = 1,n
DO j = 1,n
d(j,i) = 1.0 - c(j,i)
END DO
END DO
DO j = 2, n
a = b(j) - b(j-1)
DO i = 2, n
191
c(i,j) = a*c(i-1,j) + d(i,j)

END DO
END DO
WRITE (*,*) Vastaus:, c(n,n)
END PROGRAM taulukko
4. Mrittele kaksi osoitinmuuttujaa. Aseta toinen osoittamaan yksiulotteiseen reaalilukutaulukkoon

ja toinen saman taulukon kuudenteen alkioon.

5. Kyt osoitinmuuttujia sijoittamaan edellisen tehtvn taulukon a jrjestysluvultaan parillisiin alkioihin arvo 1.0 ja parittomiin alkioihin
arvo 1.0. Taulukon arvojen tulee siten olla seuraavan listan mukaisia:
(1.0, 1.0, 1.0, 1.0, . . . ).
6. Tee aliohjelma, joka palauttaa osoitinmuuttujassa halutun kokoisen
taulukon. Anna taulukon koko aliohjelman argumenttina. Voit kytt
aliohjelmaa esimerkiksi seuraavasti:
CALL varaa(p, n)
7. Lis tss luvussa mriteltyyn listojen ksittelyyn aliohjelma, joka

poistaa listasta alkion, jonka avain annetaan:
CALL poista(lista,luku)
8. Alkulukuteoreeman mukaan
lim
(n)
= 1,
n/ ln n
miss (n) on kokonaislukua n pienempien alkulukujen lukumr.

Tutki osamrn (n)/(n/ ln n) kyttytymist, kun n on k 105 , k =
1, 2, . . . , 20.
9. Kirjoita siskkiset DO-silmukat, joilla lasketaan matriisitulo
cjk =
aji bik , j = 1, . . . , l, k = 1, . . . n,
i=1
miss matriisi A on kooltaan lm ja B on kooltaan mn. Testaa koodisi

nopeutta MATMUL-standardialiohjelmaan verrattuna. Onko silmukoiden
jrjestyksell merkityst laskentanopeuteen? Voit lisksi testata BLASkirjaston matriisitulorutiinin SGEMM nopeutta [Haa98, HHL+ 02].
10. Laske matriisin transpoosi aliohjelmalla TRANSPOSE ja vertaa nopeutta
itse kirjoittamaasi koodiin. Onko silmukoiden jrjestyksell merkityst
laskentanopeuteen?
192
Fortran 95/2003
12
Tiedon sytt ja tulostus
Fortran 95:ss on monipuoliset mahdollisuudet tiedon syttn ja tulostamiseen. Aluksi esittelemme yksinkertaiset syttja tulostuslauseet, jotka
muotoilevat tulostuksen automaattisesti. Sen jlkeen ksittelemme syttja tulostuslauseiden yleist rakennetta ja muotoilukoodeja. Kerromme mys
tiedostojen ksittelyst, binrisest sytst ja tulostuksesta sek suorasaantitiedostoista. Lopuksi kerromme muun muassa merkkijonoihin kirjoittamisesta sek virhetilanteiden ksittelyst.
12.1
Sytt ja tulostus
Sytt ja tulostus on olennainen osa jokaista tietokoneohjelmaa. Ohjelma

voi kysy lhttietoja nppimistlt ja palauttaa laskentatuloksia nytlle.
Ohjelma voi mys lukea tiedostoista ja kirjoittaa tiedostoihin, tai ohjelma
voi vuorovaikuttaa ympristns kanssa muulla tavoin (esimerkkin prosessinohjaus).
Tietokoneohjelmat lukevat sytttietonsa syttlauseiden avulla. Tulostuslauseilla voidaan kirjoittaa laskentatuloksia kuvaruudulle tai tiedostoihin.
Ohjelman sisll voidaan avata tiedostoja lukemista tai kirjoittamista varten. Kuvassa 12.1 havainnollistetaan tiedonsiirtoa.
Kun siirrt ohjelmaa toiseen tietokonearkkitehtuuriin, voit joutua muuttamaan syttja tulostuslauseita. Ohjelman selkeyden vuoksi nm lauseet
on syyt kirjoittaa selvsti erilleen muusta ohjelmakoodista, jolloin niiden
lytminen ja muuttaminen on helppoa. Oman itsenisen syttja tulostusmoduulin tekeminen saattaa olla paras tapa tehd helposti siirrettv
koodia.
Kirjoittaessasi ohjelmaa voit aluksi kytt yksinkertaisia, tiedot automaattisesti muotoilevia syttja tulostuslauseita. Ohjelman toiminnan varmistamiseksi voit kytt tilapisi tulostuslauseita, joilla varmistutaan vlitulosten oikeellisuudesta. Poista nm lopullisesta ohjelmaversiosta ja kiinnit lisksi huomiota tulostuksen muotoiluun. Hyvn ohjelmointityyliin kuuluu lisksi tarkistaa sytttietojen oikeellisuus sek varautua sytn ja tulostuksen virhetilanteisiin. Ohjelman virheit voi paikantaa mys erityisten
virheenjljitysohjelmien (debugger) avulla.
12. Tiedon sytt ja tulostus
Nppimist
Tiedosto levyll
jne.
Nyttpte
Paperitulostin
Tiedosto levyll
jne.
193
Sytt
INTEGER
REAL
COMPLEX
LOGICAL
CHARACTER
Skalaarit
Taulukot
Rakenteiset tyypit
Tulostus
INTEGER
REAL
COMPLEX
LOGICAL
CHARACTER
Skalaarit
Taulukot
Rakenteiset tyypit
Kuva 12.1: Tiedon siirtyminen sytss ja tulostuksessa.
12.2
Yksinkertaiset syttja tulostuslauseet
Fortranin syttja tulostuslauseet READ ja PRINT tulostavat ja lukevat oletusarvoisesti ptteelt. Lauseiden kytt on esitelty seuraavassa esimerkiss:
PROGRAM kulmikas
IMPLICIT NONE
REAL :: alpha
PRINT *, Anna kulma alpha
READ *, alpha
PRINT *, Kulman sini ja kosini ovat , &
SIN(alpha), COS(alpha)
END PROGRAM kulmikas
Ohjelman ajo voisi nytt esimerkiksi tlt:

Anna kulma alpha
1.5152
Kulman sini ja kosini ovat 0.9984549284 0.5556767061E-01
Ohjelmassa symboli * ilmaisee, ett kntj tulkitsee syttvirtaa automaattisesti syttmuuttujien tyyppien mukaan ja muotoilee tulostuksen automaattisesti. Esimerkiss annettiin PRINT-lauseelle argumentiksi lista erityyppisi muuttujia. Mys sytss ohjelma voi lukea useille muuttujille
arvot samalla READ-lauseella. Perkkiset sytettvt arvot erotetaan vlilynnill tai pilkulla, tai ne voi mys kirjoittaa eri riveille.
Edell esitettyjen yksinkertaisten READ- ja PRINT-lauseiden sijaan kannattaa
useimmiten kytt lauseita READ ja WRITE seuraavaan tapaan:
PROGRAM kulmikas
IMPLICIT NONE
REAL :: alpha
WRITE (*,*) Anna kulma alpha
194
Fortran 95/2003
READ (*,*) alpha

WRITE (*,*) Kulman sini ja kosini ovat , &
SIN(alpha), COS(alpha)
END PROGRAM kulmikas
Tm ohjelma toimii tsmlleen samoin kuin edellinen. WRITE- ja READlauseissa ensimminen symboli * ilmaisee, ett kytetn oletusarvoisia
syttja tulostuskanavia ja toinen symboli * viittaa oletusmuotoiluun.
12.3
Listan ohjaama muotoilu
Edell esitellyt syttja tulostuslauseet olivat esimerkkej oletusmuotoilusta eli listan ohjaamasta muotoilusta (list-directed formatting), josta kerromme tss hieman tarkemmin. Myhemmin kerromme sarakesidonnaisesta
sytst ja tulostuksesta, jota kytetn muotoilukoodien avulla.
12.3.1 Listan ohjaama sytt

Listan ohjaamassa sytss (symboli * syttlauseissa) tietokone lukee ptteelt tietoa niin kauan, kunnes READ-lauseessa esitetyt muuttujat ovat saaneet arvonsa tai kunnes tulee virhetilanne. Yksi READ-lause voi tten lukea
arvoja usealta syterivilt. Toisaalta READ-lause lukee aina kokonaisen rivin,
joten viimeisten sytttietojen jlkeen voi laittaa vapaamuotoisia tekstikommentteja.
Perkkiset sytteet erotetaan joko vlilynneill tai pilkuilla. Perkkisten
pilkkujen vliss ajatellaan olevan tyhj arvo, joka ei muuta vastaavan muuttujan arvoa. Sytteell / lopetetaan READ-lauseen suoritus, jolloin syttlistassa jljell olevien muuttujien arvoja ei muuteta.
Listan ohjaamassa sytss kokonais- ja reaaliluvut annetaan sellaisenaan,
kompleksiluvut suluissa olevina lukupareina, merkkijonot heittomerkkien
() tai lainausmerkkien (") sisll ja loogiset muuttujat arvoina T (tosi) tai F
(eptosi). Useita perkkisi numeerisia arvoja voi sytt mys tyyliin r*v ,
miss r on toistokerroin ja v on arvo.
Eriss tapauksissa voi merkkijonolausekkeet sytt sellaisenaan ilman
heittomerkkej. Ehtona tlle on, ett
merkkijonolauseke ei sisll vlilyntej, pilkkuja tai vinoviivaa /
merkkijonolauseke ei jatku usealle riville
lausekkeen ensimminen merkki ei ole heittomerkki tai lainausmerkki "
merkkijonon alussa ei ole numeroa, jonka perss on asteriski *.
Seuraavassa ohjelmanosassa luetaan samalla READ-lauseella useita eri tyyppisi muuttujia:
195
INTEGER :: i
REAL :: x
COMPLEX :: z
LOGICAL :: totuus
READ (*,*) i, x, nimi, z, totuus
Esimerkkisytteit ohjelmalle voivat olla esimerkiksi

2 3.0 "Aku Ankka" (1.0, 0.0) F Roskaa
2, 3, Aku, (0, 1), T
2, 3 Iines (0.0, 3.14), T
3 1.41
Tupu
(3,5) T
Ensimmisess sytteess rivin lopussa oli kommentti Roskaa. Viimeinen

syte on jaettu vapaasti kolmelle eri riville.
Seuraavassa ohjelmanosassa on kolmelle kokonaislukumuuttujalle annettu
alkuarvo ja niille luetaan arvot READ-lauseella.
INTEGER :: a = 3, b = 4, c = 5
READ (*,*) a, b, c
Alla olevassa taulukossa on esitetty ohjelmalle annettuja syterivej ja muuttujien arvoja syterivin lukemisen jlkeen.
Sytetty rivi
2 -1 -3
1, 3, 2
2, , 0
3*0 Nollaus
1 / loppuu
Muuttujien arvot lukemisen jlkeen

a
b
c
2
1
2
0
1
1
3
4
0
4
3
2
0
0
5
Huomaa erityisesti kolmannella rivill pilkkujen vliss annettu tyhj arvo,

joka ei muuta muuttujien arvoja. Neljnnell rivill sytmme kolme nollaarvoa, ja tmn jlkeen rivill on kommentti. Viimeisell rivill lopetamme
lukemisen merkill /, mink jlkeen rivill on kommentti.
12.3.2 Listan ohjaama tulostus

Listan ohjaamassa tulostuksessa (tulostuslauseissa symboli *) tietokone ptt itse sopivan esitysmuodon tulostettaville muuttujille. Muuttujien vliin
tulostetaan vlilynti tai pilkku, ja tulostus jaetaan automaattisesti eri riveille. Tulostuksen alkuun tulee vhintn yksi vlilynti. Kntj voi mys
tulostaa perkkiset samat arvot esimerkiksi muodossa 3*1.0.
196
Fortran 95/2003
Oletusarvoisesti merkkijonot tulostetaan sellaisenaan ja perkkisten merkkijonolausekkeiden vliin ei tule erotinta. Kaikkien muiden muuttujatyyppien osalta listan ohjaamaa tulostusta voidaan suoraan kytt listan ohjaamassa sytss. OPEN-lauseen DELIM-tarkentimella voidaan listan ohjaamaa
tulostusta muuttaa siten, ett merkkijonojen ymprille tulostetaan lainausmerkki tai heittomerkki. Oletus on DELIM=NONE. Muita vaihtoehtoja ovat
APOSTROPHE eli heittomerkki () ja QUOTE eli lainausmerkki (").
Seuraava ohjelmanptk tulostaa eri tyyppisi muuttujia listan ohjaamalla
tulostuksella:
INTEGER :: i = 3
REAL :: x = 3.14
CHARACTER(LEN=*), PARAMETER :: kehote = "Avot"
WRITE (*,*) i, kehote, x
Ohjelman tulostus voisi nytt esimerkiksi seuraavalta:

3Avot
3.140000
Huomaa, ett esimerkkitulostuksessa kokonaisluku 3 ja sit seuraava merkkijonolauseke kirjoitettiin suoraan perkkin.
12.4
Sytt- ja tulostuslauseet
Tss esittelemme syttja tulostuslauseiden tydelliset muodot, joissa

listan ohjaaman muotoilun symboli * voidaan korvata muotoilukoodilla ja
joille voidaan antaa kanavanumero tiedostojen ksittely varten.
Lauseet WRITE ja PRINT tulostavat tietoa, ja lause READ lukee tietoa. READlauseella on kaksi muotoa, ilman kanavanumeroa ja kanavanumeron kanssa.
Seuraavat syttesimerkit kyttvt oletuskanavaa ja listan ohjaamaa muotoilua ja ovat toiminnaltaan identtisi:
READ *, n, x, y
READ (*,*) n, x, y
READ (UNIT=*,FMT=*) n, x, y
Samoin seuraavat tulostuslauseet ovat toiminnaltaan identtisi:

PRINT *, Alkio (, i, ,, j, ) =, a(i,j)
WRITE (*,*) Alkio (, i, ,, j, ) =, a(i,j)
WRITE (UNIT=*,FMT=*) Alkio (, i, ,, j, ) =, a(i,j)
Fortranin syttja tulostuslauseet ovat yleisess muodossaan seuraavat:

PRINT fmt, iolist
WRITE (unit, fmt) iolist
READ fmt, iolist
READ (unit, fmt) iolist
Tydellisess muodossaan syttja tulostuslauseet ottavat argumenteikseen kanavanumeron (unit) sek muotoilukoodin (fmt). Lisksi tarvitaan tu-
197
lostuslista (iolist) eli lista luettavista tai tulostettavista muuttujista tai lausekkeista.
Kanavanumero mahdollistaa lukemisen ja kirjoittamisen ulkoisesta tiedostosta. Oletusarvoista syttja tulostuskanavaa merkitn symbolilla *. Tiedostojen avaamista ja kanavanumeroita ksitelln sivulla 204.
12.5
Muotoilukoodit
Muotoilukoodi mr, miten tieto pit sytn tai tulostuksen yhteydess muotoilla. Muotoilukoodi siis ilmaisee, kuinka leven kenttn ja miten
muotoiltuna kukin muuttuja tulisi kirjoittaa. Muotoilukoodi voidaan antaa
eri tavoin: merkkijonovakiona, merkkijonolausekkeena, merkkijonomuuttujana tai FORMAT-lauseen lausenumerona. Aikaisemmissa esimerkeiss muotoilukoodi korvattiin symbolilla *, jolloin valittiin listan ohjaama muotoilu.
Seuraavassa esimerkiss on muotoilukoodi I5 ilmaistu kolmella eri tavalla.
Tm koodi tulostaa kokonaisluvun n viisi merkki leven kenttn.
PROGRAM tulosta
IMPLICIT NONE
INTEGER :: n = 34
CHARACTER(LEN=*), PARAMETER :: form = (I5)
WRITE (*, (I5)) n
WRITE (*, form) n
WRITE (*, 30) n
30 FORMAT (I5)
END PROGRAM tulosta
! Merkkivakio muotoilukoodina
! Merkkijonomuuttuja (tss vakio)
! FORMAT-lauseen kytt
FORMAT-lauseen kytt tulisi vltt. FORMAT-lauseen ja rivinumeroiden

kytt heikent ohjelman luettavuutta, koska samaan toimintoon liittyv
koodia on eri paikoissa ohjelmatiedostoa. Saman asian voi hoitaa selkemmin kyttmll merkkijonomuuttujaa tai nimetty merkkijonovakiota.
Fortranissa kannattaa kytt listan ohjaamaa sytt useimmissa tapauksissa. Sytn muotoilukoodit ovat vahvasti sarakesidonnaisia: kyttjn tytyy kirjoittaa sytettv tieto tsmlleen oikeisiin sarakkeisiin kullakin rivill. Fortranissa ei ole muotoilukoodia, joka lukisi tuntemattoman mittaisen
kokonaisluvun tai reaaliluvun.
Tulostuksessa muotoilukoodien kytt selvent tulostusta verrattuna listan ohjaamaan tulostukseen. Toisaalta tulostuksessakin tytyy aina ilmoittaa kentn leveys. Automaattinen kentn leveyden valinta toimii vain listan
ohjaaman tulostuksen yhteydess.
Seuraavassa esittelemme trkeimmt kokonaislukujen, reaalilukujen ja
merkkijonojen ksittelyyn tarkoitetut muotoilukoodit. Yhteenveto muotoilukoodeista on annettu taulukossa 12.1.
Muotoilukoodeihin liittyy kentn leveys. Sytss luetaan kentn leveyden
mukainen mr merkkej ja yritetn tulkita ne kyseisen tietotyyppin.
198
Fortran 95/2003
Tulostuksessa kokonais- ja reaaliluvut tulevat kentn oikeaan laitaan. Jos

tulostettavassa luvussa on enemmn desimaaleja kuin kentss on tilaa,
tytetn kentt merkeill *.
Taulukko 12.1: Yhteenveto eri tietotyypeille sopivista muotoilukoodeista. Merkint
w tarkoittaa kentn leveytt, d desimaaliosan pituutta ja e eksponentin pituutta.
Tietotyyppi
Muotoilukoodi Esimerkki
Kokonaisluvut
Kokonaisluvut binriesityksen
Kokonaisluvut oktaaliesityksen
Kokonaisluvut heksadesimaaliesityksen
Iw
Bw
Ow
Zw
I5
B8
O5
Z4
Reaaliluvut desimaaliesityksen
Fw .d
F7.4
Reaaliluvut eksponenttiesityksen
Tekniikan esitysmuoto
Tieteellinen esitysmuoto
Ew .d
Ew .dEe
ENw .d
ESw .d
E12.3
E12.3E4
EN12.3
ES12.3
Loogiset muuttujat
Lw
L7
Merkkijonot
A
Aw
A
A20
Yleinen esitystapa
Gw .d
G9.3
12.5.1 Kokonaisluvut
Kokonaislukujen muotoilukoodi on I. Koodin jlkeen ilmoitetaan kentn
leveys, esimerkiksi I5. Valinnaisesti voi kentn leveyden jlkeen ilmoittaa
tulostettavien numeroiden vhimmismrn (esim. I5.3), jolloin pienten
lukujen edelle tulostetaan nollia.
Seuraavassa on kokonaislukuja tulostava esimerkkiohjelma:
WRITE (*,(I5)) 10
WRITE (*,(I5.3)) 10
WRITE (*,(I5)) 100000

10
010
*****
Viimeisell rivill luvun esitys oli liian leve viiden merkin kenttn, jolloin
tulostettiin *-merkkej.
Kokonaisluvut voi mys tulostaa binri-, oktaali- tai heksadesimaaliesityksen muotoilukoodeilla B, O tai Z. Nit kytetn samoin kuin I-muotoilukoodia.
Kokonaislukujen sytss luetaan aina kentn leveyden mittainen mr
199
merkkej tai rivin loppuun asti. Lukujen vliss olevat vlilynnit eivt ole
merkitsevi. Muotoilukoodien kytt voi helposti johtaa virhetilanteisiin, jos
luvut eivt ole tsmlleen oikeissa sarakkeissa.
Alla olevassa taulukossa on esitetty sytettyj merkkej ja niist luettuja
kokonaislukuja, kun luvut luetaan seuraavilla lauseilla:
INTEGER :: i, j
READ (*, (2I5)) i, j
Syte
1234567890
123
45
123 45
1 3 4 5 6 4
Luetut luvut
12345
123
12
134
67890
45
345
56
12.5.2 Reaaliluvut
Reaaliluvut voidaan tulostaa desimaaliesityksen (koodi F) tai eksponenttiesityksen (koodi E). Kumpaankin koodiin liittyy kentn leveys ja desimaalien lukumr, esimerkiksi F9.3 tai E12.3. Desimaalipiste sek eksponentin esitys sisltyvt sallittuun kokonaispituuteen. E-koodille voi antaa mys
eksponenttiosan pituuden, esimerkiksi E15.3E4.
Seuraavat esimerkit valaisevat F- ja E-koodien kytt:
WRITE
WRITE
WRITE
WRITE
WRITE
WRITE
(*,
(*,
(*,
(*,
(*,
(*,
(F7.2)) 12.3443
(F9.4)) 12.3443
(F9.4)) 37283845.3872
(E12.3)) 12.3443
(E12.5)) 1.243E-5
(E15.3E4)) 1.243E-5
Esimerkkien tulostus nytt tlt:

12.34
12.3443
*********
0.123E+02
0.12430E-04
0.124E-0004
Muotoilukoodista E on olemassa tekniseen esitykseen tarkoitettu muunnos

EN, jolle eksponentti on kolmella jaollinen. Lisksi on kytettviss tieteelliseen esitykseen tarkoitettu muunnos ES, jolle desimaalipisteen vasemmalla
puolella oleva luku on yhden ja kymmenen vlill.
Seuraavassa on esimerkkej reaalilukujen tulostamisesta:
WRITE
WRITE
WRITE
WRITE
(*,(F9.3)) 0.0345
(*,(E12.3)) 0.0345
(*,(EN12.3)) 0.0345
(*,(ES12.3)) 0.0345
200
Fortran 95/2003
Tulostukseksi saadaan:
0.034
0.345E-01
34.500E-03
3.450E-02
Tiedon sytss reaalilukujen muotoilukoodit Fw .d ja Ew .d toimivat seuraavasti: ohjelma lukee joka tapauksessa kentn leveyden w ilmoittaman
mrn merkkej tai kunnes rivi loppuu. Numeroiden vliss olevat vlilynnit eivt oletusarvoisesti ole merkitsevi.
Jos sytetyss luvussa on desimaalipiste, mr se desimaaliosan alun.
Tllin muotoilukoodin (esimerkiksi Fw .d) desimaalien mrll d ei ole
merkityst. Jos luvussa ei ole desimaalipistett, tulkitaan oikeanpuoleiset d
merkki desimaalipisteen oikealla puolella olevaksi desimaaliosaksi.
Luvut voi sytt mys eksponenttimuodossa, vaikkapa esitysmuodossa
2.1E5, 2.1E+5 tai 2.1+5. Esimerkiksi jos luetaan reaalilukuja lauseella
READ (*,(F7.2)) x
muuntuvat luvut taulukon 12.2 mukaisesti. Taulukon toiselta rivilt huomataan, ett vlilyntej ei otettu huomioon. Kolmas rivi osoittaa, ett luvusta kytettiin kaikki nelj desimaalia, vaikka muotoilukoodissa oli ilmoitettu
kentn leveydeksi kaksi. Kentn leveytt kytetn vasta silloin, kun sytetyss luvussa ei ole desimaalipistett. Esimerkeiss ilman desimaalipistett
sytetyt luvut tulkitaan sadasosina eli kaksi oikeanpuolimmaista lukua tulkitaan desimaaliosaksi. Lisksi taulukossa on esimerkkej eksponenttimuotoisesta sytst, jossa eksponenttia osoittavan e-kirjaimen voi halutessaan
jtt pois.
Taulukko 12.2: Tiedon syttminen muotoilukoodin (F7.2) avulla.
Syte
Luettu reaaliluku
2.1
2 . 1
-2.3142
21
2
1324
1.2e1
1.2e-1
-1.2-2
2.1
2.1
-2.3142
0.21
0.02
13.24
12
0.12
-0.012
Kompleksilukuja varten tulee antaa kaksi muotoilukoodia, reaali- ja imaginriosalle erikseen. Seuraavassa on esimerkki tst:
COMPLEX :: z = (0.3234, 3.423)
201
WRITE (*,(F6.3, E9.2)) z
Tulostuksena on 0.323 0.34E+01. Samoin sytss luetaan reaali- ja imaginriosa erikseen omilla muotoilukoodeilla. Kytettess listan ohjaamaa
muotoilua (symboli *) luetaan ja tulostetaan kompleksiluvut sulkujen sisll
olevina lukupareina. Jos kompleksiluku tulostettaisiin kyttmll esimerkiksi muotoilukoodia (F6.3), tulostuisi ensin reaaliosa, tmn jlkeen
rivinvaihto ja lopuksi luvun imaginriosa omalle rivilleen.
12.5.4 Merkkijonot
Merkkijonoja muotoillaan koodilla A, jolle annetaan parametriksi kentn leveys. Jos merkkijono on lyhyempi kuin kentn leveys, sijoitetaan merkkijono
kentn oikeaan laitaan. Jos merkkijono on pidempi kuin kentt, katkaistaan
merkkej merkkijonon lopusta. Merkkijonojen muotoilukoodia voi kytt
mys ilman kentn leveytt, jolloin koko merkkijonolauseke tulostetaan tai
luetaan.
Seuraavassa on esimerkkej merkkijonojen tulostamisesta:
WRITE (*,(A4)) Kuk
WRITE (*,(A4)) Kukkuluuruu
WRITE (*,(A)) Kukkuluuruu
Tm ohjelman tulostus nytt seuraavalta:

Kuk
Kukk
Kukkuluuruu
12.5.5 Yleinen muotoilukoodi

Yleinen muotoilukoodi Gw .d toimii reaaliluvuille luvun suuruuden mukaan
kuten muotoilukoodit Fw .d tai Ew .d. F-koodin desimaaliosaa kavennetaan
kuitenkin siten, ett kentn kokonaisleveys on sama kuin E-koodille poislukien eksponenttiosa. Kokonaisluvuille muotoilukoodi G toimii kuten koodi
Iw ja merkkijonoille kuten koodi Aw .
Taulukossa 12.3 on esimerkkej muotoilukoodilla G12.5 tulostetuista reaaliluvuista.
Taulukko 12.3: Muotoilukoodi G12.5 reaalilukujen tulostuksessa.
Reaaliluku
Tulostus
0.0000234
0.1832
12.328
1343.43
3628372.843
.23400E-04
.18320
12.328
1343.4
.36284E+07
202
Fortran 95/2003
12.5.6 Ohjauskoodit
Trkeimmt sytn ja tulostuksen ohjauskoodit on esitetty taulukossa 12.4.
Koodi TR toimii tsmlleen samoin kuin koodi X.
Taulukko 12.4: Sytn ja tulostuksen ohjauskoodeja.
Tehtv
Koodi Esimerkki
Rivinvaihto
Absoluuttinen sarkaus
Suhteellinen sarkaus oikealle
Tulosta vlilyntej
Suhteellinen sarkaus vasemmalle
Vlilynnit eivt vaikuta sytss (oletus)
Vlilynnit tulkitaan nolliksi sytss
Tulosta plusmerkki luvun eteen
l tulosta plusmerkki luvun eteen
/
Tn
TRn
nX
TLn
BN
BZ
SP
SS
12.6
(I5,/,I8)
(I5,T20,I5)
(I5,TR5,I5)
(I5,5X,I5)
(I5,TL3,I5)
(BN,I5)
(BZ,I5)
(SP,I5)
(SS,I5)
Muotoilukoodien yhdistminen ja
tulostuslistat
Usein tulostuslistassa on monta lauseketta, ja muotoilukoodi sislt muotoiluohjeet nille eri tietotyypeille. Muotoilukoodi voi sislt yll esiteltyj
eri tietotyyppien koodeja, ohjauskoodeja, merkkijonovakioita sek toistorakenteita.
Esimerkiksi viisi perkkist kokonaislukua voidaan tulostaa muotoilukoodilla (5I8) ja kolme kokonaisluku-reaalilukuparia muotoilukoodilla
(3(I5,F8.3))
Jos muotoilukoodi loppuu ennen kuin kaikki tulostuslistan alkiot on ksitelty, tulostetaan rivinvaihto ja aloitetaan koodin kyttminen alusta.
Seuraava ohjelma havainnollistaa tulostuslistoja:
PROGRAM tulosta
IMPLICIT NONE
REAL, DIMENSION(5) :: a = 1
WRITE (*,("Taulukko a", 5G9.3)) a
WRITE (*,("Rivi ", 3G9.3)) a
END PROGRAM tulosta

Taulukko a 1.00
1.00
1.00
Rivi 1.00
1.00
1.00
Rivi 1.00
1.00
1.00
1.00
203
Muotoilukoodin toistoon voi vaikuttaa kyttmll sulkuja. Esimerkiksi muotoilukoodi (A,/,(5F7.3)) tulostaa aluksi merkkijonon ja rivinvaihdon
sek lopuksi reaalilukuja, viisi lukua riville. Siis muotoilukoodin toistaminen
aloitetaan lopussa olevien sulkujen sislt. Seuraavassa on tst esimerkki:
PROGRAM toisto
IMPLICIT NONE
INTEGER :: i
WRITE (*,(A,/,(5F7.3))) Lukujono:, &
(SIN(i/10.0), i = 1, 12)
END PROGRAM toisto

Lukujono:
0.100 0.199
0.565 0.644
0.891 0.932
0.296
0.717
0.389
0.783
0.479
0.841
Tulostuslista voi koostua toistolausekkeesta, jonka tosin voi usein korvata

taulukkosyntaksilla:
PROGRAM lue
IMPLICIT NONE
INTEGER :: i
READ (*,*) (a(i), i=1,5)
READ (*,*) a
READ (*,*) a(1:5)
END PROGRAM lue
Tss kaikki READ-lauseet toimivat samoin.

Koko taulukkoa voi siten sytss tai tulostuksessa ksitell yhten kokonaisuutena. Samoin rakenteisen tietotyypin voi tulostaa yhdell lauseella,
jos tietotyyppi ei sisll osoitinmuuttujia.
Fortran 95 (mutta ei Fortran 90) mahdollistaa tulostuksen muotoilun minimilevyiseen kenttn. Muotoilukoodeille I, B, O, Z ja F voi antaa kentn leveydeksi arvon nolla, ja tllin tulostetaan mahdollisimman pieneen tilaan:
PROGRAM minimi_tulos
WRITE (*,(3(I0,:,"; "))) 12, -130, 14000
WRITE (*,(3(F0.4,:,"; "))) 1.23e2, -12.3, 1.23e5
END PROGRAM minimi_tulos

12; -130; 14000
123.0000; -12.3000; 123000.0000
Luvut tulostuivat puolipisteell ja vlilynnill erotettuina. Kytimme merkki : lopettamaan muotoilukoodin kytn, kun viimeinen tulostuslistan luku
on tulostettu.
204
Fortran 95/2003
12.7
Tietueen osan tulostaminen tai lukeminen
Normaalisti sytt- tai tulostuslausekkeen suorituksen jlkeen siirrytn

seuraavalle riville. Rivinvaihdon voi est READ- tai WRITE-lauseen mreell
ADVANCE=NO. Tt tekniikkaa ei voi kytt, jos lauseessa kytetn listan
ohjaamaa muotoilua eli *-muotoilukoodia.
Seuraava ohjelma lukee samalta rivilt ensin taulukon dimension, sitten varaa tilan ja sen jlkeen lukee taulukon alkiot.
PROGRAM lue_taulukko
IMPLICIT NONE
REAL, ALLOCATABLE, DIMENSION(:) :: a
INTEGER :: i, n
READ (*, (I2), ADVANCE=NO) n
ALLOCATE (a(n))
READ (*,*) (a(i), i=1,n)
END PROGRAM lue_taulukko
Ohjelmalle voisi antaa esimerkiksi syterivin

3 3.14 2.71 1.4142
Seuraavat lauseet kirjoittavat ensin rivin alkuun kehotteen ja lukevat samalta

rivilt kokonaisluvun.
WRITE (*,(A), ADVANCE=NO) >
READ (*,*) n
12.8
Tiedostojen ksittely
Seuraavissa kappaleissa kerrotaan tiedostojen ksittelyst ja niiden liittmisest syttja tulostuskanaviin. OPEN-lauseella avataan tiedosto ja liitetn se annettuun kanavanumeroon, INQUIRE-lauseella kyselln tiedoston
tai kanavan ominaisuuksia ja CLOSE-lauseella suljetaan tiedosto. Auki oleva
tiedosto voidaan kelata alkuun lauseella REWIND ja rivin verran taaksepin
lauseella BACKSPACE. Mys edell esitetyt READ- ja WRITE-lauseet ottavat parametrikseen kanavanumeron.
12.8.1 Tiedoston avaaminen

Yleisin OPEN-lauseen muoto on seuraava:
OPEN ([UNIT=]kanava, FILE=tiedosto)
Tiedosto data.txt avataan esimerkiksi seuraavasti:

OPEN (10, FILE=data.txt)
Tmn jlkeen kanavalle 10 tehtv sytt ja tulostus ohjautuu tiedostoon

data.txt. Tiedosto suljetaan CLOSE-lauseella.
205
Yleens kanava 5 on syttkanava (standard input), ja kanava 6 on tulostuskanava (standard output). Lisksi useissa Unix-jrjestelmiss kanava 0
on varattu virheilmoituksille (standard error). Nm kanavat on valmiiksi
avattu, joten nit kanavanumeroita voi suoraan kytt syttja tulostuslauseissa. Kuten tmn luvun alussa esitettiin, syttja tulostuslauseissa
kanavanumero voidaan korvata merkill *, jolloin luetaan ja kirjoitetaan
ptteelt.
Monissa tietokoneissa kyttjrjestelm avaa uuden tiedoston, jos kirjoitetaan kanavanumerolle, jota ei ole liitetty mihinkn tiedostoon. Esimerkiksi
kanavalle 7 kirjoittaminen saattaa tuottaa tiedoston fort.7. Toisissa tietokoneissa avaamattomalle kanavalle kirjoittaminen tuottaa virheilmoituksen.
Seuraavassa esimerkiss luetaan tiedostosta data.a taulukon koko, varataan taulukko ja luetaan taulukon alkiot.
PROGRAM lue_taulukko
IMPLICIT NONE
REAL, ALLOCATABLE, DIMENSION(:) :: a
INTEGER :: n
OPEN (10, FILE=data.a)
READ (10, *) n
ALLOCATE (a(n))
READ (10, *) a
CLOSE (10)
END PROGRAM lue_taulukko
OPEN-lauseelle voi antaa useita tarkentimia. Tiedoston olemassaoloa ohjataan tarkentimella STATUS=st, miss st on merkkijonolauseke, jonka arvo
on OLD, NEW, REPLACE, SCRATCH tai UNKNOWN.
Arvo OLD edellytt, ett tiedosto on olemassa, ja arvo NEW puolestaan,
ett tiedosto ei saa olla olemassa. Tarkentimen arvolla REPLACE avattu
vanha tiedosto tuhotaan, muuten avataan uusi tiedosto. Arvo SCRATCH
luo tilapistiedoston, joka hvitetn CLOSE-lauseen suorituksen yhteydess. Tss tapauksessa tiedostolle ei saa antaa nime.
Seuraavassa esimerkiss avataan tilapistiedosto kanavalle 10:
OPEN (10, STATUS=SCRATCH)
Tarkentimella POSITION mrtn, mihin kohtaan tiedostoa aloitetaan kirjoittaa. Yleisimmin kytetty arvo tlle tarkenteelle on APPEND, jolloin kirjoitetaan tiedoston pern:
OPEN(20, FILE=data.a, POSITION=APPEND)
Tarkennin ACTION est lukeminsen tai kirjoittamisen. Arvo READ est

WRITE-lauseen kytn ja arvo WRITE est READ-lauseen kytn. Arvo
READWRITE sallii kummatkin. Tarkentimen ACTION oletusarvo vaihtelee
tietokoneesta toiseen.
206
Fortran 95/2003
12.8.2 Binritiedostot
Fortranin oletusarvoinen tiedostotyyppi on tekstitiedosto, joka sislt luettavassa muodossa tallennettuja merkkijonoja ja lukuja. Niden lukeminen
ja kirjoittaminen on esimerkki formatoidusta tiedonsiirrosta.
Kuitenkin suurten tiedostojen ksittelyss on edullisempaa kytt binritiedostoja, joissa luvut ja merkkijonot on ilmaistu tietokoneen sisisess esitysmuodossa. Binritiedostojen kytt on formatoimatonta tiedonsiirtoa.
Fortranin binritiedostoilla on oma, kyseisest Fortran-toteutuksesta riippuva sisinen esitysmuoto. Siten esimerkiksi C-kielell kirjoitettu binritiedosto ei sellaisenaan ole yleens luettavissa Fortran-ohjelmalla.
Binritiedostot voivat sst huomattavasti tilaa, ne ovat nopeampia kytt, ja lisksi lukujen tarkkuus ei heikkene lukuja kirjoitusoperaatioiden
takia. Binritiedostojen huono puoli on, ett ihminen ei saa niiden sisllst
selv, eik tiedostoja voi yleens siirt eri tietokoneiden vlill.
Binritiedosto avataan kytten OPEN-lauseessa tarkenninta
FORM=UNFORMATTED
Binritiedostojen lukuja kirjoituslauseissa ei kytet muotoilukoodeja.

Alla on annettu esimerkki tilapisen binritiedoston ksittelyst:
PROGRAM binaari
IMPLICIT NONE
OPEN (10, STATUS=SCRATCH, FORM=UNFORMATTED)
WRITE (10) a
REWIND 10
...
READ (10) a
CLOSE (10)
END PROGRAM binaari
Tss siis tilapinen binritiedosto avattiin OPEN-lauseella kanavalle 10.

Tiedostoon kirjoitettiin taulukko a. Huomaa, ett WRITE-lauseessa ei kytetty minknlaisia muotoilukoodeja. Tiedosto kelattiin alkuun REWIND-lauseella. Myhemmin ohjelmassa taulukko luettiin uudelleen sisn READ-lauseella
jlleen ilman muotoilukoodeja. Kun tm tilapistiedosto suljetaan CLOSElauseella, se hvitetn automaattisesti.
Tilapistiedostojen kytt oli aikaisemmin yleist, koska koneiden keskusmuistit olivat pieni. Nyt niit tarvitaan vain todella isoille taulukoille, joita
ei voida pit koneen keskusmuistissa. Tilapistiedostojen kytt on huomattavasti hitaampaa kuin esimerkiksi saman datan ksittely taulukoilla.
12.8.3 Suorasaantitiedostot
Fortranin tiedostot ovat oletusarvoisesti perkkissaantitiedostoja, joita luetaan alusta alkaen tietue eli rivi kerrallaan. Fortranissa voi mys avata suo-
207
rasaantitiedostoja, jolloin tiedostosta voidaan lukea rivej halutussa jrjestyksess. Suorasaantitiedostot ovat oletusarvoisesti binrisi.
Suorasaantitiedostot ovat hydyllisi esimerkiksi monissa tietokantasovelluksissa. Tietueita ei tarvitse kirjoittaa jrjestyksess, vaan tiedostossa voi
olla reiki eli tyhji kirjoittamattomia tietueita.
Suorasaantitiedostot avataan kytten OPEN-lauseen tarkenninta
ACCESS=DIRECT
Oletusarvoisesti tiedostot ovat binrisi, joten tekstimuotoisen suorasaantitiedoston avaukseen tulee liitt tarkennin FORM=FORMATTED. Tietueen
pituus on ilmoitettava avauksessa tarkentimella RECL=pituus. Tietueen pituus ilmaistaan tekstitiedostoille merkkein ja binritiedostoille yleens tavuina. Luku- ja kirjoituslauseissa tulee valita tietue tarkentimella REC=tietue,
miss tietue tarkoittaa tietueen jrjestysnumeroa.
Alla olevassa esimerkiss avataan kaksi suorasaantitiedostoa, toinen binrisen ja toinen tekstimuotoisena.
INTEGER, DIMENSION(10) :: r
OPEN (10, FILE=dir.bin, ACCESS=DIRECT, RECL=40)
OPEN (20, FILE=dir.txt, ACCESS=DIRECT, &
FORM=FORMATTED, RECL=10)
WRITE (10, REC=13) r
WRITE (20, (F10.3), REC=3) r
Binritiedostoon kirjoitetaan tietue numero 13, joka sislt kymmenalkioisen kokonaislukutaulukon. Tss oletetaan, ett kokonaislukumuuttuja vie nelj tavua keskusmuistia ja vaatii vastaavan mrn tilaa binritiedostossa. Tekstitiedostoon kirjoitetaan kokonaislukutaulukon alkiot kukin
omaksi tietueekseen tietueesta 3 alkaen.
12.8.4 Tiedoston tai kanavan ominaisuuksien kysely

Tiedoston tai kanavan ominaisuuksia voi kysell INQUIRE-lauseella, joka on
muotoa
INQUIRE (UNIT=kanava, lista)
tai muotoa
INQUIRE (FILE=tiedosto, lista)
Argumentti lista sislt joukon lismreit ja niihin liittyvi muuttujia.

INQUIRE-lauseen suorituksen jlkeen kukin muuttuja sislt tiedoston tai
kanavan ominaisuuksia kuvaavan arvon. Trkeimmt INQUIRE-lauseen mreet ja niihin liittyvien muuttujien tyypit on annettu taulukossa 12.5.
Seuraava esimerkki kuvaa INQUIRE-lauseen kytt:
PROGRAM kysely
IMPLICIT NONE
LOGICAL :: olemassa
208
Fortran 95/2003
Taulukko 12.5: INQUIRE-lauseeseen liittyvi mreit ja niiden paluumuuttujien

tyypit.
Mre
Selitys
Muuttujatyyppi
EXIST
OPENED
NAME
ACCESS
FORM
ACTION
NEXTREC
IOLENGTH
Onko tiedosto olemassa

Onko tiedosto tai kanava avattu
Kanavalle avatun tiedoston nimi
Saantitapa
FORMATTED tai UNFORMATTED
READ, WRITE tai READWRITE
Seuraavan tietueen numero
Tulostettavan datan viem tila
Looginen
Looginen
Merkkijono
Merkkijono
Merkkijono
Merkkijono
Kokonaisluku
Kokonaisluku
INTEGER :: n
REAL :: x
CHARACTER(LEN=12) :: saanti, muoto
INQUIRE (FILE=data.bin, EXIST=olemassa)
IF (.NOT. olemassa) &
STOP Tiedostoa data.bin ei ole olemassa!
OPEN(UNIT=10, FILE=data.bin, ACCESS=DIRECT, RECL=4)
READ(10, REC=3) x
INQUIRE (UNIT=10, ACCESS=saanti, FORM=muoto, NEXTREC=n)
WRITE (*,*) saanti, muoto, n, x
END PROGRAM kysely
Ohjelmassa testataan tiedoston data.bin olemassaoloa ja lopetetaan, jos

tiedostoa ei lydy. Jos tiedosto on olemassa, se avataan binrisen suorasaantitiedostona, jonka tietueen pituus on nelj tavua. Tiedostosta luetaan
reaaliluku tietueesta 3. Sen jlkeen kysytn INQUIRE-lauseella, mik on tiedoston saantitapa, onko kyseess binrinen vai tekstitiedosto sek seuraavaksi ksiteltvn tietueen numeroa. INQUIRE-lauseen suorituksen jlkeen
nm tiedot ovat muuttujissa saanti, muoto ja n, jotka tulostetaan ptteelle.
DIRECT
UNFORMATTED
4 23.00000000
INQUIRE-lauseella saa mys selville tulostettavan muuttujalistan esityspituuden tulostuslaitteella. Tll tavalla voi esimerkiksi saada selville muuttujien binrisen talletustavan viemn tilan (yleens sama kuin lukujen viem
keskusmuistitila):
INTEGER :: len
INTEGER :: i
INQUIRE (IOLENGTH=len) i
WRITE (*,*) Kokonaisluvut, len, tavua
12.9
209
Luku merkkijonoista ja kirjoitus

merkkijonoihin
READ- ja WRITE-lauseissa voi kanavanumeron korvata merkkijonomuuttujan nimell, jolloin syttja tulostusoperaatiot kohdistuvat thn merkkijonoon (ns. sisinen tiedosto). Tt voidaan kytt hyvksi esimerkiksi
luotaessa tilapistiedostojen nimi tai analysoitaessa ja muunnettaessa syterivej.
Seuraavassa esimerkiss muodostetaan tilapistiedoston nimi kirjoittamalla
se merkkijonomuuttujaan (esimerkitiedoston nimi on temp.007).
CHARACTER(LEN=20) :: tnimi
INTEGER :: n = 7
WRITE (tnimi, ("temp.", I3.3)) n
PRINT *, tnimi
OPEN(10, FILE=tnimi)
Seuraavassa tiedoston nimi muodostetaan merkkijonon, vuosiluvun ja ptteen yhdistelmst:

IMPLICIT NONE
INTEGER :: vuosi CHARACTER(LEN=2) :: hiukkaskoko
CHARACTER(LEN=10) :: tnimi
hiukkaskoko = pm
vuosi = 2007
WRITE (tnimi, (A,I4.4,".dat")) hiukkaskoko, vuosi
WRITE (*,(A)) tnimi
OPEN(10, FILE=tnimi)
Tss tiedoston nimeksi tulee pm2007.dat.

Seuraava esimerkki lukee ptteelt reaaliluvun, joka sislt desimaalipilkun. Rivi luetaan ensin merkkijonomuuttujaan. Pilkku muutetaan desimaalipisteeksi. Lopuksi luku luetaan merkkijonomuuttujasta reaalilukumuuttujaan.
CHARACTER(LEN=80) :: rivi
REAL :: numero
INTEGER :: pilkku
READ (*,(A)) rivi
pilkku = INDEX(rivi, ,)
rivi(pilkku:pilkku) = .
READ (rivi, *) numero
Standardifunktio INDEX hakee rivin ensimmisen pilkun sarakeindeksin. Ohjelma olettaa, ett rivill on tsmlleen yksi pilkku.
210
Fortran 95/2003
12.10
NAMELIST-rakenne
NAMELIST-rakenne mahdollistaa muuttujaryhmn ksittelemisen yhten kokonaisuutena sytss ja tulostuksessa. Muuttujille voidaan antaa arvot niiden nimien mukaan vapaassa jrjestyksess. Erityisen hydyllinen NAMELISTrakenne on silloin, kun muuttujille on annettu alkuarvot ja osalle muuttujista luetaan uudet arvot tiedostosta.
NAMELIST-rakenteen kytt havainnollistaa seuraava esimerkki:
PROGRAM leivo
IMPLICIT NONE
INTEGER :: jauhot = 1, sokeri = 1, munat = 1
NAMELIST /kakku/ jauhot, sokeri, munat
READ (*, NML=kakku)
WRITE (*, NML=kakku)
END PROGRAM leivo
NAMELIST-ryhmn nimi tytyy siis antaa tarkentimella NML.

Sytss NAMELIST-ryhmn ksittely aloitetaan &-merkill, jonka perss on
ryhmn nimi. Tmn jlkeen tulee joukko sijoituslauseita ryhmn muuttujille ja sytt lopetetaan merkill /. Yll olevalle ohjelmalle sytetn haluttujen muuttujien arvot ptteelt esimerkiksi seuraavasti:
&kakku munat=3, jauhot=4/
Tllin tulostus voisi nytt seuraavalta:

&KAKKU
JAUHOT=4, SOKERI=1, MUNAT=3
/
NAMELIST-rakenne on ktev esimerkiksi pienten sytttiedostojen muotoilussa, jolloin sytttiedostosta tulee itsedokumentoiva.
12.11
Virhetilanteiden ksittely
Tiedostojen ksittelyss tulisi aina varautua tilanteisiin, jossa esimerkiksi

avattavaa tiedostoa ei ole olemassa tai tiedosto loppuu kesken lukuoperaation aikana. Fortran tarjoaa tilamuuttujia virhetilanteista selvimiseen.
OPEN-lauseeseen voi list seuraavan lismreen:
IOSTAT=iovar
Tss iovar on kokonaislukumuuttuja, joka saa arvon 0, jos tiedoston avaus

onnistui, ja positiivisen arvon virhetilanteessa.
WRITE- ja READ-lauseisiin voi liitt saman lismreen:
IOSTAT=iovar
Luettaessa tiedostoa READ-lauseella saa tilamuuttuja iovar negatiivisen arvon, jos tiedosto loppuu, positiivisen arvon virhetilanteessa ja arvon nolla,
211
jos luku onnistuu. IOSTAT-mreen palauttamat virhekoodit ovat laitteistoriippuvia.

Jos IOSTAT-lismrett ei ole annettu, ohjelman suoritus voi pyshty tiedostovirheeseen. Jos tm lismre annetaan, virhetilanteista toipuminen
on ohjelmoijan vastuulla.
Seuraava esimerkki havainnollistaa virhetilanteiden ksittely:
PROGRAM io
IMPLICIT NONE
INTEGER :: avaus, luku
INTEGER, PARAMETER :: kanava = 10
CHARACTER(LEN=*), PARAMETER :: tiedosto = data.txt
REAL :: x
OPEN(kanava, FILE=tiedosto, STATUS=old, IOSTAT=avaus)
IF (avaus /= 0) THEN
WRITE (*,*) Virhe tiedoston , tiedosto,&
avaamisessa, virhekoodi:, avaus
STOP
END IF
DO
READ (kanava, *, IOSTAT=luku) x
IF (luku < 0) THEN
WRITE (*,*) Tiedoston loppu, ohjelman suoritus &
&jatkuu:, luku
EXIT
ELSE IF (luku > 0) then
WRITE (*,*) Virhe lukemisessa, virhekoodi:, luku
STOP
ELSE
WRITE (*,*) Luettu arvo:, x
END IF
END DO
WRITE (*,*) Lopullinen arvo:, x
END PROGRAM io
Sytt- ja tulostuslauseisiin voi mys liitt lausenumeroita, joihin hyptn

virhetilanteissa. Lausenumeroiden kytt ei kuitenkaan ole suositeltavaa,
koska ne vhentvt ohjelman selkeytt ja hmrtvt ohjelman loogista
rakennetta.
12.12
Yhteenveto
Tss luvussa on esitetty trkeimmt Fortranin syttja tulostusoperaatiot. Monista piirteist, erityisesti OPEN-lauseen lismreist, on ksitelty
vain oleellisimmat toiminnot. Seuraavissa luetteloissa on esitelty trkeimpien syttja tulostuslauseiden syntaksi. Valinnaiset osat on kirjoitettu
hakasulkuihin.
212
Fortran 95/2003
READ fmt [,iolist]

READ ([UNIT=]kanava, [FMT=]fmt [, IOSTAT=iostat]
[, ERR=err-lause] [,END=end-lause] [, ADVANCE=NO]) iolist
PRINT fmt [,iolist]
WRITE ([UNIT=]kanava, [FMT=]fmt [, IOSTAT=iostat]
[, ERR=err-lause] [, ADVANCE=NO]) [iolist]
BACKSPACE kanava
BACKSPACE ([UNIT=]kanava[, IOSTAT=iostat] [, ERR=err-lause])
REWIND kanava
REWIND ([UNIT=]kanava[, IOSTAT=iostat][, ERR=err-lause])
OPEN ([UNIT=]kanava, olist)
CLOSE ([UNIT=]kanava[, IOSTAT=iostat][, ERR=err-lause])
INQUIRE ([UNIT=]kanava, ilist)
INQUIRE (FILE=tiedosto, ilist)
INQUIRE (IOLENGTH=pituus) iolist
OPEN-lauseen lismreit (listassa olist) ovat muun muassa:

FILE=tiedosto
IOSTAT=iostat
ERR=err-lause
STATUS=st
ACCESS=acc
FORM=fm
RECL=rl
POSITION=pos
ACTION=act
DELIM=dlm
INQUIRE-lauseen lismreit on esitelty taulukossa 12.5 (sivu 208).

Tiedon esitysmuotoa sytss ja tulostuksessa ohjataan muotoilukoodeilla.
Eri tietotyyppien muotoilukoodeja on esitelty taulukossa 12.1 (sivu 198) ja
ohjauskoodeja taulukossa 12.4 (sivu 202).
Harjoitustehtvi
1. Mit eroa on WRITE- ja PRINT-lauseilla?
2. Seuraavassa esimerkiss on mritelty eri tavoilla Fortranin muotoilulausekkeita. Mit ohjelma tekee? Mitk mrittelyt ovat mielestsi toimivimpia?
PROGRAM muoto
IMPLICIT NONE
REAL :: x
CHARACTER(LEN=11) :: form1
CHARACTER(LEN=*), PARAMETER :: form2 = (F12.3,A)
x = 12.0
form1 = (F12.3,A)
WRITE (*, form1) x, hello
WRITE (*, form2) 2*x, hi
WRITE (*, (F12.3,A)) 3*x, hi hi
END PROGRAM muoto
213
3. Kirjoita tulostuslauseet seuraaville taulukoille:

REAL, DIMENSION(6,10) :: a
INTEGER, DIMENSION(24) :: h
CHARACTER(LEN=10), DIMENSION(6) :: mtaulu
LOGICAL, DIMENSION(2) :: ehto
COMPLEX, DIMENSION(20) :: z
4. Kirjoita listan ohjaamat syttrutiinit, jotka lukevat arvot edellisen tehtvn taulukoille. Anna esimerkki ohjelmasi sytttiedostosta.
5. Tiedostossa on formatoitua dataa seuraavan taulukon mukaisessa sarakesidonnaisessa esitysmuodossa:
Tieto
Sarakkeet Koodaus
etunimi
sukunimi
sukupuoli
siviilisty
115
2145
50
52
ik
5457
merkkijono
merkkijono
N=nainen, M=mies
0=naimaton, 1=naimisissa,
2=avoliitossa, 3=muu tai tuntematon
vuosina
Tiedosto loppuu, kun sarakkeissa 115 on teksti

Tiedoston loppu
Tiedostossa on korkeintaan 500 tietuetta eli rivi.

Kirjoita ohjelma, joka lukee tiedot edell esitetyn muotoisesta tiedostosta, laskee keskiarvon ille sek tulostaa ikjakauman ja siviilisdyn
jakauman.
6. Mit seuraava ohjelma tulostaa, kun sytteen annetaan merkkijono
0123456789?
PROGRAM tulostesti
IMPLICIT NONE
CHARACTER(LEN=7) :: mj1, mj2, mj3
READ (*, (A8,T3,A5,TR2,A)) mj1, mj2, mj3
WRITE(*, (3X,A8,3X,A5,3X,A)) mj1, mj2, mj3
WRITE(*, (3(3X,A))) mj1, mj2, mj3
END PROGRAM tulostesti
7. Laske ja trigonometristen funktioiden sin x, cos x ja tan x arvot, kun

kulma x ky 0:sta 90:een asteeseen yhden asteen vlein. Kyt sopivia
muotoilukoodeja.
8. Lue tiedostosta 20 reaalilukua, yksi rivi kohti. Tulosta luvut toiseen
tiedostoon knteisess jrjestyksess. Varaudu mys lukemisessa tuleviin virhetilanteisiin.
Muunna ohjelmaasi siten, ett luettavien reaalilukujen mr on mielivaltainen. Ohjelma tiet, ett tiedosto on loppunut, kun IOSTAT on
negatiivinen. Lue kanavasta * ja kirjoita kanavalle *. Tllin ohjelmaa
voi kytt Unixissa seuraavasti:
214
Fortran 95/2003
% ohjelma < sytetiedosto > tulostustiedosto
9. Kirjoita ohjelma, joka tulostaa funktion f (x) = (sin x)/(x + cos x)2
kuvaajan tekstiptteelle esimerkiksi seuraavasti:
Syt ala- ja ylraja: 2 5
Syt laskentapisteiden lukumr
ja kuvaajan leveys vaakatasossa: 15 32
x:
y:
:.........:.........:.........:.
2.000
0.362
+
2.214
0.307
+
2.429
0.234
+
2.643
0.154
+
2.857
0.078
+
3.071
0.016
+
3.286 -0.027
+
3.500 -0.053 +
3.714 -0.066 +
3.929 -0.068 +
4.143 -0.065 +
4.357 -0.058 +
4.571 -0.050 +
4.786 -0.042
+
5.000 -0.034
+
10. Kirjoita ohjelma, joka tulostaa kertotaulun luvuille 1, . . . , 16.

11. Kirjoita ohjelma, joka kertoo kuinka monta kertaa annettu sana esiintyy
tiedostossa. Tiedoston nimi luetaan ptteelt. Varaudu mys tiedoston
avaamisessa tuleviin virhetilanteisiin.
12. Kirjoita ohjelma, joka tulostaa kuukauden kalenterin, kun sille kerrotaan vuosi ja kuukausi. Tietyn pivmrn viikonpivn saat selville
kaavasta
w = MOD(k + FLOOR(2.6*m - 0.2) - 2*c + y &
+ FLOOR(y/4) + FLOOR(c/4), 7)
Tss muuttuja k on kuukauden piv (1, 2, . . . , 31). Muuttuja m on kuukausi: 1 = maaliskuu, 2 = huhtikuu, . . . , 10 = joulukuu, 11 = tammikuu,
12 = helmikuu (ksittele tammikuu ja helmikuu edellisen vuoden kuukausina). Muuttuja c on vuosisata, esimerkiksi vuonna 1987 on c = 19.
Muuttuja y on vuosi eli vuonna 1987 on y = 87, paitsi tammi- ja helmikuussa y = 86. Muuttuja w on viikonpiv: 0 = sunnuntai, . . . , 6 =
lauantai.
13. Kirjoita ohjelma, joka laskee vektorin euklidisen normin. Vertaa ohjelmasi tehokkuutta BLAS-rutiiniin SNRM2, kun vektorin alkioiden lukumr on suuri.
13. Standardiproseduurit
13
215
Standardiproseduurit
Kymme lpi Fortran 95 -kielen standardiproseduurit (intrinsic procedure),

jotka ovat joko funktioita tai aliohjelmia. Standardifunktioista kytetn
toisinaan mys nime varusfunktiot.
13.1
Standardiproseduurien perusksitteit
Fortran 95 -standardi sislt 115 standardialiohjelmaa ja -funktiota. Useimmat standardiproseduurit ovat geneerisi, joten samaa funktio- tai aliohjelmakutsua voi kytt eri tyyppisille argumenteille. Tten funktiokutsua
SIN(x) voi kytt eri lajien reaali- ja kompleksilukuargumenteille.
Osa standardiproseduureista on alkioittaisia (elemental), mik tarkoittaa, ett proseduurikutsu kohdistuu kuhunkin argumentin alkioon erikseen. Esimerkiksi ohjelmakoodi
REAL, DIMENSION(100) :: x, y
INTRINSIC SIN
x = SIN(y)
laskee sinifunktion arvot kaikille taulukon y alkioiden arvoille.

Kyselyfunktioiden (inquiry functions) avulla voi selvitt argumenttien ominaisuuksia. Esimerkiksi reaalimuuttujan x numeerisen tarkkuuden saa selville funktiokutsulla PRECISION(x).
Muunnosfunktioiden (transformational functions) avulla muunnetaan (yleens) taulukkotyyppisi argumentteja toiseen muotoon. Esimerkiksi muunnosfunktio SUM laskee argumenttitaulukon alkioiden summan.
Standardiproseduurit on hyv esitell INTRINSIC-lauseessa ohjelmayksikn
alussa ennen suoritettavia lauseita, jolloin ohjelmakoodin lukija tiet, mit
standardiproseduureja ohjelmassa kytetn. Mrittely
INTRINSIC SIN
kertoo, ett kytmme standardifunktiota SIN. INTRINSIC-lauseen kytt

on pakollista, jos standardifunktio vlitetn proseduurin todellisena argumenttina.
216
Fortran 95/2003
13.2
Standardiproseduurien kuvauksia
Standardiproseduurien kuvaukset on koottu tmn luvun seuraavassa lueteltuihin taulukoihin:

Taulukon sislt
Taulukko Sivu
Sekalaisia varusfunktioita
Kellonaika ja pivmr
Satunnaislukujen tuottaminen
Trigonometriset sek logaritmi- ja eksponenttifunktiot
Numeerinen tarkkuus ja konversiot
Numeerisia ja matemaattisia funktiota
Merkkijonojen ksittely
Taulukko-operaatioita
Lis taulukko-operaatioita
Proseduureja bittien ksittelyyn
13.1
13.2
13.3
13.4
13.5
13.6
13.7
13.8
13.9
13.10
217
217
218
220
221
222
223
224
225
226
Taulukoissa on kerrottu kunkin proseduurin kutsusyntaksi sek argumenttien mahdolliset tyypit. Lisksi on kerrottu argumenttien INTENT-arvot (IN,
OUT tai INOUT) sek ilmoitettu, onko argumentti valinnainen (OPTIONAL). Proseduuri voi palauttaa tulokset OUT- tai INOUT-tyyppisiss argumenteissa ja
lukee sytteen IN- tai INOUT-tyyppisist argumenteista.
Funktion palauttaman arvon tyyppi on esitetty seuraavaan tapaan:
L = ALLOCATED(array) tutki, onko taulukolle varattu tilaa
Kirjain L tarkoittaa, ett funktion arvo on tyyppi LOGICAL. Muita mahdollisuuksia ovat: I eli INTEGER, R eli REAL, D eli DOUBLE PRECISION, C eli
CHARACTER ja Z eli COMPLEX.
Kaksoistarkkuuden tyyppi DOUBLE PRECISION esiintyy taulukoissa historiallisista syist. Tmn tyypin kytn voi korvata parametrisoidulla reaalilukutyypill.
Jos funktion arvo riippuu argumenttien tyypist, on tm merkitty seuraavasti:
* = MAXVAL(array,dim,mask) maksimiarvo
Monissa taulukkoja ksitteleviss proseduureissa kytetn argumenttina

mask-muuttujaa. Argumentti mask on looginen (yleens taulukkotyyppinen)
muuttuja, joka ohjaa proseduurin toimintaa. Funktion MAXVAL argumentin
mask tulee olla saman muotoinen looginen taulukko kuin argumentin array.
Taulukosta array ksitelln vain ne alkiot, joita vastaava taulukon mask
arvo on tosi.
Aliohjelmakutsut on merkitty taulukoihin seuraavasti:
CALL NIMI(argumentit)
Jos useammalla proseduurilla on sama argumenttilista, on nm proseduurit lueteltu taulukossa perkkin ja niiden alapuolella on yhteinen argumenttien kuvaus.
217
Huomaa, ett jos funktiokutsun argumentti on kompleksilukuvakio, tytyy

aliohjelmakutsussa kytt kaksinkertaisia sulkuja:
z = SQRT((1.0,-1.0))
Fortranin standardiproseduurien kytt esitelln mys oppaan muissa luvuissa. Kerromme Fortranin lausekkeista luvussa 6 (sivu 67). Havainnollistamme taulukkojen ksittely luvussa 11 (sivu 164).
Taulukko 13.1: Sekalaisia standardifunktioita.

Argumentti
Argumentin tyyppi
Suunta Valinnaisuus
L = ALLOCATED(array) tutki, onko taulukolle varattu tilaa

array
ALLOCATABLE
IN
L = ASSOCIATED(pointer,target) osoittaako osoitinmuuttuja

kohteeseen
pointer
POINTER
IN
target
POINTER tai TARGET
IN
OPTIONAL
L = PRESENT(a) onko argumentti annettu proseduurin kutsussa
a
mik tahansa tyyppi
IN
* = NULL(mold) palauttaa kohteesta irrotetun osoittimen

mold
mik tahansa osoitin
IN
OPTIONAL
Taulukko 13.2: Kellonaika, pivmr ja cpu-aika.

Argumentti
Argumentin tyyppi
Suunta Valinnaisuus
CALL DATE_AND_TIME(date,time,zone,values) pivmr ja

kellonaika
date
CHARACTER(LEN=8)
OUT
OPTIONAL
time
CHARACTER(LEN=10)
OUT
OPTIONAL
zone
CHARACTER(LEN=5)
OUT
OPTIONAL
values
INTEGER, DIMENSION(8)
OUT
OPTIONAL
CALL SYSTEM_CLOCK(count,count_rate,count_max) tietokoneen
seinkelloaika
count
INTEGER
OUT
OPTIONAL
count_rate INTEGER
OUT
OPTIONAL
count_max INTEGER
OUT
OPTIONAL
CALL CPU_TIME(time) prosessorin CPU-aika sekunneissa
time
REAL
OUT
218
Fortran 95/2003
Taulukko 13.3: Satunnaislukujen tuottaminen.

Argumentti
Argumentin tyyppi
Suunta Valinnaisuus
CALL RANDOM_NUMBER(harvest) satunnaislukujen tuottaminen

harvest
REAL
OUT
CALL RANDOM_SEED(size,put,get) siemenlukujen asetus ja haku
size
put
get
13.3
INTEGER
INTEGER, DIMENSION(m)
OUT
IN
OUT
OPTIONAL
OPTIONAL
OPTIONAL
Esimerkki: kellonaika ja pivmr
Taulukossa 13.2 esitetyill rutiineilla saat selville kellonajan ja pivmrn:

PROGRAM ajanhetki
IMPLICIT NONE
INTEGER, PARAMETER:: &
r8 = SELECTED_REAL_KIND(12,100)
CHARACTER(LEN=8) :: pvm
CHARACTER(LEN=10) :: aika
CALL DATE_AND_TIME(date = pvm)
CALL DATE_AND_TIME(time = aika)
WRITE (*,(A,A8)) Pvm: , pvm
WRITE (*,(A,A10)) Aika: , aika
WRITE (*,(A,F10.3)) Sekunnit: , sekunnit()
CONTAINS
FUNCTION sekunnit() RESULT (aika)
IMPLICIT NONE
REAL(r8) :: aika
INTEGER, DIMENSION(8) :: t
CALL DATE_AND_TIME(values = t)
aika = t(5)*3600.0_r8+t(6)*60.0_r8+t(7)+t(8)/1000.0_r8
END FUNCTION sekunnit
END PROGRAM ajanhetki

Pvm: 19980728
Aika: 110039.849
Sekunnit: 39639.851
Kyseess on siis vuoden 1998 heinkuun 28. piv, ja kello on hiukan yli
11:00:39. Ohjelman tulostamat sekunnit puolestaan vastaavat kuluvan vuorokauden kellonaikaa sekunteina.
13.4
219
Esimerkki: satunnaisluvut ja kellonaika
Taulukossa 13.3 on esitelty satunnaislukujen tuottamiseen tarvittavat rutiinit. Satunnaisluvut riippuvat satunnaislukugeneraattorin alustamiseen kytetyist siemenluvuista. Samoilla siemenluvuilla saadaan aina sama satunnaislukusarja. Jos siemenlukua ei aseteta, ohjelma voi tuottaa eri ajokerroilla
samat satunnaisluvut.
Seuraavassa ohjelmassa alustamme satunnaislukugeneraattorin kellonajan
perusteella laskettavalla siemenluvulla ja tuotamme halutun mrn tasajakautuneita satunnaislukuja vlilt [a, b).
PROGRAM satunnainen
IMPLICIT NONE
CALL alusta
CALL tulosta
CONTAINS
SUBROUTINE alusta
IMPLICIT NONE
INTEGER :: koko, tila
INTEGER, DIMENSION(8) :: t
INTEGER, DIMENSION(:), ALLOCATABLE :: siemen
CALL RANDOM_SEED(size=koko)
ALLOCATE(siemen(koko), stat=tila)
IF (tila > 0) STOP Tilanvaraus eponnistui!
siemen = 100*t(7) + t(8)/10
CALL RANDOM_SEED(put=siemen)
END SUBROUTINE alusta
SUBROUTINE tulosta
IMPLICIT NONE
INTEGER :: n, tila
REAL :: a, b
REAL, DIMENSION(:), ALLOCATABLE :: luvut
write (*,(A),ADVANCE=NO) Anna ala- ja ylraja:
READ (*,*) a, b
WRITE (*,(A),ADVANCE=NO) &
Anna satunnaislukujen lukumr:
READ (*,*) n
ALLOCATE(luvut(n), stat=tila)
IF (tila > 0) STOP Tilanvaraus eponnistui!
CALL RANDOM_NUMBER(luvut)
WRITE (*,(A)) Satunnaisluvut:
WRITE (*,(6(F10.6))) a + (b-a)*luvut
END SUBROUTINE tulosta
END PROGRAM satunnainen
Satunnaislukugeneraattori alustettiin aliohjelmassa alusta ja satunnaislukujen tuottaminen tehtiin aliohjelmassa tulosta. Satunnaislukugeneraattorin vaatiman siemenlukutaulukon koko selvitettiin aliohjelmakutsulla
CALL RANDOM_SEED(size=koko)
220
Fortran 95/2003
Siemenlukutaulukon sisllksi asetettiin rutiinin DATE_AND_TIME palauttamista sekunneista ja millisekunneista laskettu kokonaisluku, joka on vlilt
[0, 29999]:
siemen = 100*t(7) + t(8)/10
CALL RANDOM_SEED(put=siemen)
Satunnaisluvut tuotettiin reaalilukutaulukkoon luvut aliohjelmakutsulla

CALL RANDOM_NUMBER(luvut)
Tuloksena on tasajakautuneita satunnaislukuja vlilt [0, 1). Tulostuslausekkeessa a + (b-a)*luvut luvut skaalataan vlille [a, b).
Anna ala- ja ylraja: -1 1
Anna satunnaislukujen lukumr: 10
Satunnaisluvut:
-0.253170 0.654368 -0.700821 -0.983755 -0.877386
0.135530 -0.885027 -0.704163 -0.781958
0.948415
Taulukko 13.4: Trigonometriset sek logaritmi- ja eksponenttifunktiot.

Argumentti
Argumentin tyyppi
R = ACOS(x) arkuskosini
R = ASIN(x) arkussini
x
REAL, |x| 1
Suunta Valinnaisuus
IN
R = ATAN(x) arkustangentti
R = TAN(x) tangentti
x
REAL
* = COS(x) kosini
* = SIN(x) sini
x
REAL tai COMPLEX
IN
IN
R = ATAN2(y,x) arkustangentti arvolle Y/X

y
REAL
x
REAL
R = COSH(x) hyperbolinen kosini
IN
IN
R = SINH(x) hyperbolinen sini

R = TANH(x) hyperbolinen tangentti
x
REAL
IN
* = EXP(x) eksponenttifunktio
* = LOG(x) luonnollinen logaritmi
x
REAL tai COMPLEX
IN
R = LOG10(x) kymmenkantainen logaritmi

x
REAL, x > 0
IN
221
Taulukko 13.5: Numeerinen tarkkuus ja konversiot.

Argumentti
Argumentin tyyppi
I = DIGITS(x) merkitsevien numeroiden mr

I = RADIX(x) aritmetiikan kantaluku
x
INTEGER tai REAL
I = RANGE(x) eksponentin lukualue
Suunta Valinnaisuus
IN
x
numeerinen
IN
* = HUGE(x) suurin luku annetun muuttujan tyyppi
x
INTEGER tai REAL
IN
R = EPSILON(x) muuttujan x tyyppi vastaava kone-epsilon

I = EXPONENT(x) luvun x eksponenttiosa
I = MAXEXPONENT(x) suurin eksponentti annetun muuttujan tyyppi
I = MINEXPONENT(x) pienin eksponentti annetun muuttujan tyyppi
I = PRECISION(x) muuttujan tyypin tarkkuus desimaaleina
R = RRSPACING(x) suhteellisen tarkkuuden knteisarvo
R = SPACING(x) luvun absoluuttinen tarkkuus
R = TINY(x) muuttujan x tyyppi vastaava pienin positiivinen luku
x
REAL
IN
Z = CMPLX(x,y,kind) muunnos kompleksiluvuksi

x
numeerinen
IN
y
INTEGER tai REAL
IN
OPTIONAL
kind
INTEGER
IN
OPTIONAL
D = DBLE(a) muunnos kaksoistarkkuuteen
a
numeerinen
IN
I = INT(a,kind) muunnos kokonaisluvuksi (katkaisu nollaa kohti)
a
numeerinen
IN
kind
INTEGER
IN
OPTIONAL
L = LOGICAL(l,kind) muunnos loogisen tyypin eri lajien vlill
l
LOGICAL
kind
INTEGER
R = REAL(a,kind) muunnos reaaliluvuksi
a
numeerinen
kind
INTEGER
I = KIND(x) selvitetn muuttujan tyyppi
IN
IN
OPTIONAL
IN
IN
OPTIONAL
x
mik tahansa perustyyppi
IN
I = SELECTED_INT_KIND(r) halutun tarkkuuden kokonaislukutyyppi
r
INTEGER
IN
I = SELECTED_REAL_KIND(p,r) halutun tarkkuuden reaalilukutyyppi
p
INTEGER
r
INTEGER
R = SCALE(x,i) skaalaa reaaliluku: x = x*(b**i)
x
REAL
i
INTEGER
R = SET_EXPONENT(x,i) aseta luvun x eksponentti
x
i
REAL
INTEGER
IN
IN
IN
IN
IN
IN
OPTIONAL
OPTIONAL
222
Fortran 95/2003
Taulukko 13.6: Numeerisia ja matemaattisia funktioita.

Argumentti
Argumentin tyyppi
* = ABS(a) luvun itseisarvo

a
numeerinen
R = AIMAG(z) kompleksiluvun imaginaariosa
Suunta Valinnaisuus
IN
z
COMPLEX
IN
R = AINT(a,kind) katkaisu kokonaislukuun nollan suuntaan
R = ANINT(a,kind) lhin kokonaisluku
a
REAL
IN
kind
INTEGER
IN
I = CEILING(a,kind) pyristys ylspin
a
REAL
kind
INTEGER
Z = CONJG(z) kompleksikonjugaatti
IN
IN
z
COMPLEX
* = DIM(x,y) erotus x y tai nolla jos x y < 0
IN
x
INTEGER tai REAL
y
sama kuin x
D = DPROD(x,y) kaksoistarkkuuden tulo: x y
IN
IN
x
oletustarkkuuden REAL
y
oletustarkkuuden REAL
I = FLOOR(a,kind) katkaisu alaspin
IN
IN
a
REAL
kind
INTEGER
R = FRACTION(x) luvun murto-osa
x
REAL
* = MAX(a1,a2,a3, . . . ) lukujen maksimiarvo
IN
IN
OPTIONAL
OPTIONAL
OPTIONAL
IN
* = MIN(a1,a2,a3, . . . ) lukujen minimiarvo

a1
a2
a3
* = MOD(a,p)
INTEGER tai REAL

sama kuin a1
sama kuin a1
arvo a - p*INT(a/p)
IN
IN
IN
OPTIONAL
* = MODULO(a,p) arvo a modulo p

a
INTEGER tai REAL
IN
p
sama kuin a
IN
R = NEAREST(x,s) lhin reaaliluku annettuun suuntaan
x
REAL
IN
s
REAL
IN
I = NINT(a,kind) lhin kokonaisluku
a
REAL
kind
INTEGER
* = SIGN(a,b) a:n itseisarvo samanmerkkisen kuin b
a
INTEGER tai REAL
b
sama kuin a
* = SQRT(x) nelijuuri: x
x
REAL tai COMPLEX
IN
IN
IN
IN
IN
OPTIONAL
223
Taulukko 13.7: Merkkijonojen ksittely.

Argumentti
Argumentin tyyppi
Suunta Valinnaisuus
C = ACHAR(i) paikassa i oleva ASCII-merkki

i
INTEGER
IN
C = ADJUSTL(string) siirr vlilynnit merkkijonon alusta loppuun
C = ADJUSTR(string) siirr vlilynnit merkkijonon lopusta alkuun
string
CHARACTER
C = CHAR(i,kind) paikassa i oleva merkki
IN
i
INTEGER
kind
INTEGER
I = IACHAR(c) ASCII-merkin jrjestysnumero
IN
IN
OPTIONAL
I = ICHAR(c) merkin jrjestysnumero

c
CHARACTER(LEN=1)
IN
I = INDEX(string,substring,back) osamerkkijonon alkukohta
string
CHARACTER
substring CHARACTER
back
LOGICAL
I = LEN(string) merkkijonon pituus
IN
IN
IN
OPTIONAL
I = LEN_TRIM(string) pituus ilman lopussa olevia vlilyntej

string
CHARACTER
IN
L = LGE(string_a,string_b) ASCII-jrjestyksen a b vertailu
L = LGT(string_a,string_b) ASCII-jrjestyksen a > b vertailu
L = LLE(string_a,string_b) ASCII-jrjestyksen a b vertailu
L = LLT(string_a,string_b) ASCII-jrjestyksen a < b vertailu
string_a
CHARACTER
string_b
CHARACTER
C = REPEAT(string,ncopies) toista merkkijonoa
IN
IN
string
CHARACTER
IN
ncopies
INTEGER
IN
C = SCAN(string,set,back) hae merkkej merkkijonosta
string
CHARACTER
set
CHARACTER
back
LOGICAL
C = TRIM(string) poista lopussa olevat vlilynnit
IN
IN
IN
OPTIONAL
string
CHARACTER
IN
I = VERIFY(string,set,back) tarkista, koostuuko merkkijono
annetuista merkeist
string
CHARACTER
IN
set
CHARACTER
IN
back
LOGICAL
IN
OPTIONAL
224
Fortran 95/2003
Taulukko 13.8: Taulukko-operaatioita.

Argumentti
Argumentin tyyppi
Suunta Valinnaisuus
L = ALL(mask,dim) tarkista mask-taulukon totuusarvoja

L = ANY(mask,dim) tarkista mask-taulukon totuusarvoja
I = COUNT(mask,dim) laske .true.-arvojen mrt
mask
LOGICAL, DIMENSION(n, . . . )
IN
dim
INTEGER
IN
OPTIONAL
* = CSHIFT(array,shift,dim) siirr matriisin arvoja kehss
array
taulukko
IN
shift
INTEGER
IN
dim
INTEGER
IN
OPTIONAL
* = EOSHIFT(array,shift,boundary,dim) siirr matriisin arvoja
array
taulukko
IN
shift
INTEGER
IN
boundary
sama tyyppi kuin array
IN
OPTIONAL
dim
INTEGER
IN
OPTIONAL
* = MERGE(tsource,fsource,mask) poimi arvoja kahdesta muuttujasta
tsource
mik tahansa
IN
fsource
sama kuin tsource
IN
mask
LOGICAL
IN
* = PACK(array,mask,vector) pakkaa halutut taulukon alkiot
array
mik tahansa taulukko
IN
mask
IN
vector
samaa tyyppi kuin array
IN
* = UNPACK(vector,mask,field) pura vektorin alkiot
vector
taulukko, DIMENSION(n)
IN
mask
IN
field
samaa tyyppi kuin vector
IN
* = RESHAPE(source,shape,pad,order) muunna taulukko
haluttuun muotoon
source
IN
shape
IN
pad
taulukko tyyppi source
IN
order
sama kuin shape
IN
* = SPREAD(source,dim,ncopies) kopioidaan alkioita
source
dim
INTEGER
ncopies
INTEGER
* = TRANSFER(source,mold,size) siirr dataa
source
mold
size
mik tahansa taulukko tai skalaari

INTEGER
OPTIONAL
OPTIONAL
OPTIONAL
IN
IN
IN
IN
IN
IN
OPTIONAL
225
Taulukko 13.9: Lis taulukko-operaatioita.

Argumentti
Argumentin tyyppi
Suunta Valinnaisuus
I(:) = MAXLOC(array,mask) maksimiarvon sijainti

I(:) = MAXLOC(array,dim,mask)
I(:) = MINLOC(array,mask) minimiarvon sijainti
I(:) = MINLOC(array,dim,mask)
array
INTEGER, DIMENSION(n, . . . ) tai

REAL, DIMENSION(n, . . . )
dim
INTEGER
mask
* = MAXVAL(array,dim,mask) maksimiarvo
IN
IN
IN
OPTIONAL
* = MINVAL(array,dim,mask) minimiarvo
array
INTEGER, DIMENSION(n, . . . ) tai

IN
REAL, DIMENSION(n, . . . )
dim
INTEGER
IN
mask
IN
I = LBOUND(array,dim) taulukkoindeksien alaraja(t)
OPTIONAL
OPTIONAL
I = UBOUND(array,dim) taulukkoindeksien ylraja(t)

array
taulukko
IN
dim
INTEGER
IN
I = SHAPE(source) argumentin muoto (ulottuvuuksien koot)
source
I = SIZE(array,dim) taulukon alkioiden lukumr
OPTIONAL
IN
array
IN
dim
INTEGER
IN
* = PRODUCT(array,dim,mask) taulukon alkioiden tulo
OPTIONAL
* = SUM(array,dim,mask) taulukon alkioiden summa

array
numeerinen taulukko
IN
dim
INTEGER
IN
OPTIONAL
mask
IN
OPTIONAL
* = DOT_PRODUCT(vector_a,vector_b) vektorien pistetulo
vector_a
numeerinen tai looginen
vector_b
sama kuin vector_a
* = MATMUL(matrix_a,matrix_b) matriisitulo
IN
IN
matrix_a
numeerinen tai looginen matriisi
matrix_b
numeerinen tai looginen matriisi
* = TRANSPOSE(matrix) matriisin transpoosi
IN
IN
matrix
taulukko, DIMENSION(m,n)
IN
226
Fortran 95/2003
Taulukko 13.10: Proseduureja bittien ksittelyyn.

Argumentti
Argumentin tyyppi
I = BIT_SIZE(i) kokonaisluvun bittien mr

i
INTEGER
L = BTEST(i,pos) tutki halutun bitin tilaa
Suunta Valinnaisuus
IN
I = IBCLR(i,pos) aseta haluttu bitti nollaksi

i
INTEGER
IN
pos
INTEGER
IN
I = IBITS(i,pos,len) hae kokonaisluvusta jono bittej
i
INTEGER
pos
INTEGER
len
INTEGER
I = IBSET(i,pos) aseta haluttu bitti ykkseksi
IN
IN
IN
i
INTEGER
IN
pos
INTEGER
IN
I = IAND(i,j) kokonaislukujen looginen and-operaatio
I = IEOR(i,j) biteittinen xor-operaatio (exclusive or)
I = IOR(i,j) biteittinen or-operaatio
i
INTEGER
j
sama kuin i
I = NOT(i) biteittinen looginen komplementti
i
INTEGER
IN
IN
IN
I = ISHFT(i,shift) siirr bittej oikealle tai vasemmalle

i
INTEGER
shift
INTEGER
I = ISHFTC(i,shift,size) siirr bittej kehss
IN
IN
i
INTEGER
IN
shift
INTEGER
IN
size
INTEGER
IN
OPTIONAL
CALL MVBITS(from,frompos,len,to,topos) kopioi bittej muuttujasta
toiseen
from
INTEGER
IN
frompos
INTEGER
IN
len
INTEGER
IN
to
INTEGER
INOUT
topos
INTEGER
IN
13.5
Esimerkki: bittienksittelyoperaatiot
Fortran 95:n bittienksittelyproseduurit perustuvat USA:n armeijan standardiin (MIL-STD 1753). Useimmat bittioperaatiot ovat alkioittaisia, joten niille
voi antaa mys taulukkoargumentteja.
Bittioperaatiot ksittelevt kokonaislukuja, joissa on jonossa s bitti wk ,
k = 0, 1, . . . , s 1. Bittien jrjestys on oikealta vasemmalle, ja kokonaisluvun
227
ei-negatiivinen arvo on
s1
wk 2k .
k=0
Tm kokonaislukujen esitysmalli ptee vain bittioperaatioiden yhteydess.

Bittien ksittelyproseduurit on esitelty taulukossa 13.10 sivulla 226. Seuraavassa on muutamia esimerkkej proseduurien kytst.
Kokonaislukumuuttujan i lajiin sisltyvien bittien lukumrn (edell s) saa
selville funktiokutsulla
BIT_SIZE(i)
Tietyn bitin arvon saa selville funktiokutsulla BTEST(i,pos), miss kokonaislukumuuttujan pos arvo on vlilt 0 pos < BIT_SIZE(i). Funktio
palauttaa loogisen arvon .TRUE. tai .FALSE..
Funktiokutsu IAND(i,j) palauttaa kokonaislukujen i ja j vastaaville biteille tehdyn and-operaation tuloksen. Seuraavassa on esimerkki funktion
toiminnasta:
i
j
IAND(i,j)
0
0
0
0
1
0
1
0
0
1
1
1
Kokonaislukujen i ja j tytyy olla samaa lajia. Funktio IAND palauttaa arvonaan tt lajia olevan kokonaisluvun.
Funktio ISHFTC(i,shift,size) palauttaa kokonaisluvun, jossa size oikeanpuoleista bitti on siirretty kehss |shift| paikkaa vasemmalle (tai
oikealle, jos shift on negatiivinen).
Aliohjelmakutsu
CALL MVBITS(from,frompos,len,to,topos)
kopioi kokonaisluvun from bittej kokonaislukuun to. Kopiointi alkaa paikassa frompos olevasta bitist. Kopioitavan bittijonon pituus on len. Bitit
kopioidaan paikasta topos alkaen. Argumenttien tytyy tytt seuraavat
ehdot: len 0, frompos 0, frompos+len BIT_SIZE(from), topos 0
ja topos+len BIT_SIZE(to).
13.6
Esimerkki: data pakkaaminen
Pieni kokonaislukuja voi pakata suuren tarkkuuden kokonaislukuun, koska

posa biteist on kyttmttmi. Seuraava ohjelma lukee ptteelt nelj pient kokonaislukua ja pakkaa nm kokonaisluvun sisllksi. Funktiota
bitit kytetn bittijonojen tulostamiseen ptteelle.
228
Fortran 95/2003
PROGRAM bittioperaatiot
IMPLICIT NONE
kok_luku = SELECTED_INT_KIND(9), bit_len = 8
INTEGER(KIND=kok_luku), DIMENSION(4) :: luvut
INTEGER :: i
WRITE (*,(A,I3)) Syt nelj kokonaislukua vlilt &
&0 ... , 2**bit_len-1
READ (*,*) luvut
DO i = 1, SIZE(luvut)
WRITE (*,(A,I1,":",7X,A)) Data , i, bitit(luvut(i))
END DO
WRITE (*,(A,A)) Pakattu data: , bitit(pakkaa(luvut))
CONTAINS
FUNCTION bitit(n)
IMPLICIT NONE
INTEGER(KIND=kok_luku), INTENT(IN) :: n
CHARACTER(LEN=4*bit_len) :: bitit
INTEGER :: i, lkm
bitit =
lkm = MIN(LEN(bitit), BIT_SIZE(n))
DO i = 0, lkm-1
IF(BTEST(n,i)) THEN
bitit(lkm-i:lkm-i) = 1
ELSE
bitit(lkm-i:lkm-i) = 0
END IF
END DO
END FUNCTION bitit
FUNCTION pakkaa(taulu)
IMPLICIT NONE
INTEGER, DIMENSION(:), INTENT(IN) :: taulu
INTEGER(KIND=kok_luku) :: pakkaa
INTEGER :: i, paikka
pakkaa = 0
DO i = 1, SIZE(taulu)
paikka = bit_len*(i-1)
IF ((paikka + bit_len) > BIT_SIZE(pakkaa)) RETURN
CALL MVBITS(taulu(i), 0, bit_len, pakkaa, paikka)
END DO
END FUNCTION pakkaa
END PROGRAM bittioperaatiot
Sisinen funktio bitit muuntaa kokonaisluvun merkkijonoksi, jossa esiintyy kokonaisluvun bittej vastaavat merkit 0 ja 1. Sisinen funktio
pakkaa siirt kokonaislukutaulukon taulu merkitsevt bitit funktion arvona palautettavan kokonaisluvun sislle.
Ohjelman kytt voisi nytt tlt:
Syt nelj kokonaislukua vlilt 0 ... 255
100 127 254 209
Luvut ovat: 100, 127, 254, 209
Data 1:
00000000000000000000000001100100
Data 2:
00000000000000000000000001111111
229
Data 3:
00000000000000000000000011111110
Data 4:
00000000000000000000000011010001
Pakattu data: 11010001111111100111111101100100
Datan purkaminen pakatusta muodosta on harjoitustehtvn.
13.7
Standardifunktioiden erityisnimet
Taulukoissa 13.1 . . . 13.10 on esitetty standardiproseduurien geneeriset

nimet. Kntj valitsee knnsaikana argumenttien tyypin perusteella oikean version standardiproseduurista.
Standardifunktioita voi kytt mys proseduurien todellisina argumentteina, mutta tllin on kytettv geneeristen nimien sijasta standardifunktioiden erityisnimi (specic name). Tm johtuu siit, ett vlitettess standardifunktio proseduuriin kntj ei osaa sijoittaa todellisen argumentin
paikalle standardifunktion oikeaa versiota. Standardifunktioiden erityisnimi on lueteltu taulukoissa 13.11 ja 13.12.
Taulukossa 13.11 on lueteltu ne standardifunktioiden erityisnimet, joita saa
kytt proseduurien todellisina argumentteina. Fortranin standardialiohjelmia ei saa kytt proseduurien todellisina argumentteina. Lisksi taulukossa 13.12 esitettyjen standardifunktioiden erityisnimi ei saa kytt
todellisina argumentteina.
Tyyppi I tarkoittaa kokonaislukua, R reaalilukua, D kaksoistarkkuuden reaalilukua, Z kompleksilukua ja C merkkityyppi. Erityisnimi vastaavien argumenttien ja tulosten tyypit on lueteltu vastaavassa jrjestyksess.
Seuraavassa on esimerkki erityisnimien kytst:
PROGRAM erityis
IMPLICIT NONE
INTRINSIC SIN, CSIN
REAL :: x = 1.0, y = 0.0
WRITE (*,*) Arvot: , SIN(x), SIN(CMPLX(x,y))
WRITE (*,*) Erotus: , testi(SIN, CSIN, x, y)
CONTAINS
REAL FUNCTION testi(f1, f2, x, y)
IMPLICIT NONE
REAL, EXTERNAL :: f1
COMPLEX, EXTERNAL :: f2
REAL, INTENT(IN) :: x, y
testi = ABS(f1(x) - f2(CMPLX(x,y)))
END FUNCTION testi
END PROGRAM erityis
230
Fortran 95/2003
Pohjelmassa tulostettiin sinifunktion arvot kytten geneerist nime SIN.

Lisksi sisiseen funktioon testi vlitettiin sinifunktion reaali- ja kompleksilukuargumentteja vastaavat erityisnimet SIN ja CSIN.
Arvot:
Erotus:
0.8414710
(0.8414710,0.0000000E+00)
0.0000000E+00
Taulukko 13.11: Standardifunktioiden erityisnimi. Nit erityisnimi saa kytt

todellisina argumentteina.
Geneerinen nimi
Erityisnimet
Arg. tyyppi Tulos
AINT(a)
ANINT(a)
NINT(a)
ABS(a)
MOD(a,p)
SQRT(x)
EXP(x)
LOG(x)
LOG10(x)
SIN(x)
COS(x)
TAN(x)
ASIN(x)
ACOS(x)
ATAN(x)
ATAN2(y,x)
SINH(x)
COSH(x)
TANH(x)
AIMAG(z)
CONJG(z)
LEN(s)
INDEX(s,t)
SIGN(a,b)
DIM(x,y)
AINT, DINT
ANINT, DNINT
NINT, IDNINT
IABS, ABS, DABS, CABS
MOD, AMOD, DMOD
SQRT, DSQRT, CSQRT
EXP, DEXP, CEXP
ALOG, DLOG, CLOG
ALOG10, DLOG10
SIN, DSIN, CSIN
COS, DCOS, CCOS
TAN, DTAN
ASIN, DASIN
ACOS, DACOS
ATAN, DATAN
ATAN2, DATAN2
SINH, DSINH
COSH, DCOSH
TANH, DTANH
AIMAG
CONJG
LEN
INDEX
ISIGN, SIGN, DSIGN
IDIM, DIM, DDIM
DPROD(x,y)
R, D
R, D
R, D
I, R,
I, R,
R, D,
R, D,
R, D,
R, D
R, D,
R, D,
R, D
R, D
R, D
R, D
R, D
R, D
R, D
R, D
Z
Z
C
C
I, R,
I, R,
R
13.8
D, Z
D
Z
Z
Z
Z
Z
D
D
R,
R,
I
I,
I,
R,
R,
R,
R,
R,
R,
R,
R,
R,
R,
R,
R,
R,
R,
R
Z
I
I
I,
I,
D
D
D
R, D, Z
R, D
D, Z
D, Z
D, Z
D
D, Z
D, Z
D
D
D
D
D
D
D
D
R, D
R, D
Listietoja
Tss esitetty laajempi Fortranin standardiproseduurien kuvaus lytyy ksikirjoista Fortran 90 Handbook [ABM+ 92] ja Fortran 95 Handbook [ABM+ 97]
sek Fortran-kntjien ksikirjoista. Mys teos Fortran 95 Language Guide [Geh96] soveltuu ksikirjaksi.
231
Taulukko 13.12: Standardifunktioiden erityisnimi. Niden standardifunktioiden

erityisnimi ei saa kytt todellisina argumentteina.
13.9
Geneerinen nimi
Erityisnimi Arg. tyyppi Tulos
INT(a)
INT
IFIX
IDINT
R
R
D
I
I
I
REAL(a)
REAL
FLOAT
SNGL
I
I
D
R
R
R
MAX(a1,a2,...)
MAX0
AMAX1
DMAX1
AMAX0
MAX1
I
R
D
I
R
I
R
D
R
I
MIN(a1,a2,...)
MIN0
AMIN1
DMIN1
AMIN0
MIN1
I
R
D
I
R
I
R
D
R
I
Yhteenveto
Fortran 95:een sisltyy yli sata standardiproseduuria, joita kannattaa kytt hyvksi omassa ohjelmointityss. Nm proseduurit ovat tehokas ja
luotettava tapa toteuttaa ohjelmoinnin perusoperaatioita.
Harjoitustehtvi
1. Ratkaise yhtln x n = 1 kaikki kompleksiset juuret (vihje: e2 k i = 1,
k = 0, 1, . . . ).
2. Muuta kappaleen 13.4 satunnaislukuja tuottavaa ohjelmaa siten, ett
kyttj pyydetn syttmn siemenluku.
3. Kirjoita aliohjelma, joka muuntaa napakoordinaattiesityksen (r , ) karteesisiksi koordinaateiksi (x, y). Kirjoita mys pinvastaisen muunnoksen tekev aliohjelma. Kyt hyvksi mritelmi
sin = y/r ,
cos = x/r ,

r = x2 + y 2 .
4. Laske viisialkioisten reaalilukutyypin vektoreiden sistulo standardifunktiolla DOT_PRODUCT.
232
Fortran 95/2003
5. Laske 5 4 ja 4 3 -kokoisten matriisien A ja B tulo C = AB standardifunktiolla MATMUL. Laske mys tulo C T = B T AT , miss B T on matriisin
B transpoosi jne.
6. Etsi kyttjn syttmst korkeintaan 80 merkin pituisesta merkkijonosta ensimmisen numeromerkin sijainti kytten SCAN-funktiota.
7. Kirjoita looginen funktio numerot, joka ilmoittaa, koostuuko argumenttina annettu merkkijono pelkstn numeromerkeist. Kyt apuna standardifunktiota VERIFY.
8. Mrittele aliohjelma suorakulmio, joka tulostaa halutun kokoisia suorakulmioita. Aliohjelmakutsun CALL suorakulmio(3,5) tulostus voisi nytt tlt:
+---+
!
!
+---+
Kyt apunasi REPEAT-funktiota.

9. Lis edellisen tehtvn aliohjelmaan valinnainen argumentti, joka kertoo kuinka monta kertaa vierekkin suorakulmio tulostetaan. Aliohjelmakutsun CALL suorakulmio(3,5,6) tulostus voisi nytt seuraavalta:
+---+ +---+ +---+ +---+ +---+ +---+
!
! !
! !
! !
! !
! !
!
+---+ +---+ +---+ +---+ +---+ +---+
10. Lis kappaleen 13.6 ohjelmaan funktio, joka purkaa kokonaislukumuuttujaan pakatut pienet positiiviset kokonaisluvut. Funktion tulee
palauttaa arvonaan neljn alkion mittainen kokonaislukutaulukko.
11. Tee salasanageneraattori, joka muodostaa ja tulostaa 8 merkist koostuvan satunnaisen salasanan, joka koostuu isoista ja pienist kirjaimista,
numeroista sek erikoismerkeist
!"#%&/()=?+*;:,._-<>
12. Kirjoita rutiini, joka palauttaa n alkiota vlilt [a, b] tasavlein:

a(1:n) = interval_real(a, b, n)
13. Kirjoita funktiot, jotka palauttavat arvoinaan yksiulotteisen reaalilukutaulukon, jonka alkiot muodostavat
(a) aritmeettisen jonon, jonka alkuarvo ja askel on annettu
(b) geometrisen jonon, jonka alkuarvo ja kerroin on annettu.
Funktioiden kutsut voisivat nytt seuraavilta:
a(1:n) = seq_real(start, inc, n)
b(1:n) = geomseq_real(start, coeff, n)
14. Kirjoita funktiot, jotka palauttavat yksiulotteisen reaalilukutaulukon

maksimi- ja minimialkioiden indeksin kokonaislukumuuttujaan. Funktiolle voi antaa mys valinnaisen argumentin, jolloin vain osa taulukon
alkioista otetaan mukaan maksimiarvon etsintn:
233
i = maxloci_real(vector,mask)
i = miniloci_real(vector,mask)
15. Kirjoita edellist tehtv vastaavat funktiot kokonaislukuargumenteille. Sijoita funktiot moduuliin ja mrittele niille geneeriset nimet, esimerkiksi maxloci ja miniloci.
234
Fortran 95/2003
14
Esimerkkiohjelmia
Tss luvussa kertaamme Fortran 95 -kielen mahdollisuuksia aikaisemmin

esitettyj asioita valaisevien esimerkkien avulla:
14.1
Aihe
Kappale Sivu
Nelilaskin
Datan lajittelu
Sokkelon tekeminen
Yksiulotteinen soluautomaatti
Life-soluautomaatti
Binripuu
Sukupuu
Optimointi: evoluutiostrategiat
Lineaaristen yhtlryhmien ratkaisu
14.1
14.2
14.3
14.4
14.5
14.6
14.7
14.8
14.9
234
237
243
247
253
256
261
263
269
Nelilaskin
Knteist puolalaista logiikkaa toteuttava nelilaskin toimii seuraavasti. Olkoon sytteen

5 Return 2.2 Return * Return
Tuloksena on luku 11 eli kertolaskun 5 2.2 tulos. Vastaavasti syte

10 Return 3 Return / Return
tuottaa tulokseksi luvun 3.333 . . . eli jakolaskun 10/3 tuloksen. Seuraavassa

on Fortran-ohjelma, joka simuloi tllaista laskinta. Laskin tuntee operaatiot
+, -, * ja / sek komennot Q (lopeta) ja P (tulosta luku).
PROGRAM nelilaskin
! Yksinkertainen rpn-laskin
! Pinon ksittelyoperaatiot:
USE pinomoduuli, ONLY : push, pop
IMPLICIT NONE
CHARACTER (LEN=*), PARAMETER :: kehote = rpn>
CHARACTER (LEN=80) :: rivi
14. Esimerkkiohjelmia
235
REAL :: a, b
silmukka: DO
WRITE(UNIT=*,FMT=(A),ADVANCE=no) kehote
READ (*,(A)) rivi
rivi = ADJUSTL(rivi)
IF (LEN_TRIM(rivi) /= 1) THEN
CALL lue_syote(rivi)
ELSE
SELECT CASE (rivi(1:1))
CASE (+)
a = pop(); b = pop(); CALL push(b+a)
CASE (-)
a = pop(); b = pop(); CALL push(b-a)
CASE (*)
a = pop(); b = pop(); CALL push(b*a)
CASE (/)
a = pop(); b = pop(); CALL push(b/a)
CASE (P, p)
a = pop(); WRITE (*,*) a
CASE (Q, q)
STOP
CASE DEFAULT
CALL lue_syote(rivi)
END SELECT
END IF
END DO silmukka
CONTAINS
SUBROUTINE lue_syote(rivi)
IMPLICIT NONE
CHARACTER (LEN=*), INTENT(IN) :: rivi
INTEGER :: tila
REAL :: luku
tila = 0
READ (rivi,*,IOSTAT=tila) luku
IF (tila == 0) THEN
CALL push(luku)
ELSE
WRITE (*,*) Syntaksivirhe - viimeisin &
&sytttietorivi hyltty!
END IF
END SUBROUTINE lue_syote
END PROGRAM nelilaskin
Mrittelemme moduulin pinomoduuli myhemmin tss kappaleessa. Tst moduulista ovat perisin pinon ksittelyoperaatiot pop ja push.
Ohjelma lukee kyttjn antaman syterivin 80 merkin pituiseen merkkijonomuuttujaan rivi. Alussa siirretn vlilynnit sytteen alusta loppuun.
Jos sytteess on enemmn kuin yksi vlilynnist poikkeava merkki, kyseess on luvun sisltv syte tai virhetilanne. Jos sytteen pituus on yksi
vlilynnist poikkeava merkki, on kyseess komento, yksittinen numeromerkki tai virhetilanne.
rpn> 5
236
Fortran 95/2003
rpn> 2.2
rpn> *
rpn> p
11.00000000
rpn> 10
rpn> 3
rpn> /
rpn> p
3.333333254
rpn> q
Moduulin pinomoduuli voi toteuttaa esimerkiksi seuraavasti:

MODULE pinomoduuli
! Tm moduuli toteuttaa yksinkertaisen pinon
IMPLICIT NONE
PRIVATE
INTEGER, PARAMETER :: maksimikoko = 100
TYPE :: pinotyyppi
REAL, DIMENSION(maksimikoko) :: arvot
INTEGER :: huippu
END TYPE pinotyyppi
TYPE(pinotyyppi) :: pino = pinotyyppi(0.0, 1)
PUBLIC :: pop, push
CONTAINS
SUBROUTINE push(arvo)
! Laitetaan pinoon reaaliluku
IMPLICIT NONE
REAL, INTENT(IN) :: arvo
IF (pino%huippu > maksimikoko) THEN
WRITE (*,*) "Pino on tysi"
ELSE
pino%arvot(pino%huippu) = arvo
pino%huippu = pino%huippu + 1
END IF
END SUBROUTINE push
REAL FUNCTION pop()
! Pinon pllimminen luku palautetaan
IMPLICIT NONE
IF (pino%huippu <= 1) THEN
WRITE (*,*) "Pino on tyhj"
pop = 0
ELSE
pino%huippu = pino%huippu - 1
pop = pino%arvot(pino%huippu)
END IF
END FUNCTION pop
END MODULE pinomoduuli
Moduulissa kytetty tyyppi pinotyyppi on yksityinen, sill moduulin sisltmt tieto-oliot on piilotettu kyttmll PRIVATE-lausetta. Tten voimme muuttaa pinon toteutuksen yksityiskohtia moduulin toiminnallisuuden
muuttumatta.
14.2
237
Datan lajittelu
Tss esimerkiss lajittelemme yksiulotteisia taulukkoja suuruusjrjestykseen. Ensimmisen lajittelualgoritmina kytmme sijoituslajittelua (insertion sort), joka on yksinkertainen ja riittv pienelle datamrlle (parikymment alkiota). Tmn jlkeen toteutamme Shellsort-lajittelualgoritmin
nousuindeksin laskemista varten.
14.2.1 Sijoituslajittelu
Voimme mritell reaalilukutaulukon lajittelevan aliohjelman lajittele_r
seuraavasti:
MODULE jarjestys
IMPLICIT NONE
CONTAINS
SUBROUTINE lajittele_r(taulu)
IMPLICIT NONE
REAL, INTENT(INOUT), DIMENSION(:) :: taulu
REAL :: apu
INTEGER :: i, j, n
n = SIZE(taulu)
DO i = 2, n
apu = taulu(i)
DO j = i, 2, -1
IF (taulu(j-1) <= apu) EXIT
taulu(j) = taulu(j-1)
END DO
taulu(j) = apu
END DO
END SUBROUTINE lajittele_r
END MODULE jarjestys
Aliohjelmaan lajittelu vlitetn lajiteltava taulukko taulu. Aliohjelma

palauttaa taulukon alkiot lajiteltuna kasvavaan jrjestykseen. Lajiteltavan
taulukon koko saadaan selville aliohjelmakutsulla SIZE.
Voimme kytt lajittelumoduulia seuraavasti. Aliohjelma lajittele_r otetaan kyttn USE-lauseessa nimell lajittele.
PROGRAM lajittelu_testi
USE jarjestys, ONLY : lajittele => lajittele_r
IMPLICIT NONE
REAL, DIMENSION(:), ALLOCATABLE :: d
INTEGER :: n, i, tila
WRITE (*,(A),ADVANCE=NO) Anna n>1:
READ (*,*) n
IF (n <= 1) THEN
STOP n <= 1
ELSE
ALLOCATE(d(n), STAT=tila)
IF (tila /= 0) THEN
238
Fortran 95/2003
STOP Muistinvaraus eponnistui!

ELSE
CALL RANDOM_NUMBER(d)
WRITE (*,(A,/,8(F9.5))) Data:, d
CALL lajittele(d)
WRITE (*,(A,/,8(F9.5))) Lajiteltu data:, d
END IF
END IF
END PROGRAM lajittelu_testi
Ohjelma lukee ptteelt lajiteltavan reaalilukutaulukon koon. Taulukolle d

varataan tila ALLOCATE-lauseessa ja tmn jlkeen taulukko tytetn satunnaisluvuilla. Lajittelu tehdn aliohjelmakutsulla
CALL lajittele(d)
14.2.2 Geneerinen lajitteluproseduuri

Moduulia jarjestys voi laajentaa ksittelemn mys kokonaislukuja
merkkijonotaulukoita. Kytmme geneerist nime lajittele eri lajitteluproseduureille:
MODULE jarjestys
IMPLICIT NONE
PRIVATE
INTERFACE lajittele
MODULE PROCEDURE lajittele_r, lajittele_i, &
lajittele_c
END INTERFACE
PUBLIC :: lajittele
CONTAINS
Lajitteluproseduurien mrittelyt
END MODULE jarjestys
Aliohjelma lajittele_i on lhestulkoon edell esitellyn lajittele_r-aliohjelman kopio, ainoa muutos tulee riveille:
SUBROUTINE lajittele_i(taulu)
IMPLICIT NONE
INTEGER, DIMENSION(:), INTENT(INOUT) :: taulu
INTEGER :: apu
jne.
END SUBROUTINE lajittele_i
Merkkijonotaulukkojen lajitteluun sopii seuraava aliohjelma:

SUBROUTINE lajittele_c(taulu)
IMPLICIT NONE
CHARACTER(LEN=*), DIMENSION(:), INTENT(INOUT) :: taulu
CHARACTER(LEN=LEN(taulu(1))) :: apu
jne.
END SUBROUTINE lajittele_c
239
Tmkin aliohjelma on muilta osin reaalilukuja lajittelevan aliohjelman suora kopio, sill mys merkkijonojen jrjestyksen vertailuun voi kytt operaattoria <=.
Voimme kytt geneerisen lajitteluproseduurin lajittele sisltv moduulia seuraavasti:
USE jarjestys, ONLY : lajittele
IMPLICIT NONE
REAL, DIMENSION(:), ALLOCATABLE :: dr
INTEGER, DIMENSION(:), ALLOCATABLE :: di
CHARACTER(LEN=8), DIMENSION(:), ALLOCATABLE :: dc
INTEGER :: n, i, tila
READ (*,*) n
IF (n <= 1) THEN
STOP n <= 1
ELSE
ALLOCATE(dr(n), di(n), dc(n), STAT=tila)
IF (tila /= 0) THEN
STOP Muistinvaraus eponnistui!
ELSE
CALL RANDOM_NUMBER(dr)
di = 1e6*dr
dc = teksti-
dc(:)(8:8) = CHAR(IACHAR( ) + &
MOD(di,1+IACHAR(z)-IACHAR( )))
WRITE (*,(A,/,6(F9.5))) Data:, dr
CALL lajittele(dr)
WRITE (*,(A,/,6(F9.5))) Lajiteltu data:, dr
WRITE (*,(A,/,6(I9))) Data:, di
CALL lajittele(di)
WRITE (*,(A,/,6(I9))) Lajiteltu data:, di
WRITE (*,(A,/,6(A9))) Data:, dc
CALL lajittele(dc)
WRITE (*,(A,/,6(A9))) Lajiteltu data:, dc
END IF
END IF
Pohjelmassa tytetn reaalilukutaulukko dr satunnaisluvuilla reaalilukuvlilt [0, 1). Kokonaislukutaulukon di arvot saadaan kertomalla nm
reaaliluvut miljoonalla. Merkkitaulukon dc arvoiksi asetetaan merkkijonot
teksti-c, miss c on satunnainen ASCII-merkki vlilynnin ja z-kirjaimen vlilt (katso liitett D sivulla 324).
Anna n>1: 11
Data:
0.11639 0.96485
0.88297
0.42049
0.49586
0.57739
240
Fortran 95/2003
0.94234
Lajiteltu
0.11639
0.57739
Data:
116391
942340
Lajiteltu
116391
577386
Data:
teksti-"
teksti-C
Lajiteltu
teksti-"
teksti-b
0.24316
data:
0.24316
0.68923
0.55013
0.68923
0.47643
0.42049
0.88297
0.47643
0.94234
0.49586
0.96485
0.55013
964846
243162
data:
243162
689230
882970
550126
420486
689230
495856
476426
577386
420486
882970
476426
942340
495856
964846
550126
teksti-
teksti-*
data:
teksti-*
teksti-r
teksti-x teksti-b teksti-x teksti-r

teksti-? teksti-w teksti-I
teksti-? teksti-C teksti-I teksti-
teksti-w teksti-x teksti-x
14.2.3 Nousuindeksin laskeminen

Nousuindeksi on kokonaislukutaulukko, jonka avulla taulukon alkiot saadaan indeksoitua nousevaan jrjestykseen. Nousuindeksi voidaan laskea
Shellsort-algoritmia kytten (katso esimerkiksi teoksia [CLR90, Sed84]):
MODULE nousu
IMPLICIT NONE
PRIVATE
PUBLIC :: nousuindeksi
CONTAINS
FUNCTION nousuindeksi(taulu) RESULT(idx)
! Shellsort-algoritmi
IMPLICIT NONE
REAL, DIMENSION(:), INTENT(IN) :: taulu
INTEGER, DIMENSION(SIZE(taulu)) :: idx
INTEGER :: n, askel, i, j, apuidx
n = SIZE(taulu)
idx = (/ (i, i = 1, n) /)
askel = 1
DO WHILE (askel <= n)
askel = 3*askel + 1
END DO
DO
askel = askel/3
DO i = askel+1, n
apuidx = idx(i)
j = i
DO WHILE (j > askel)
IF (taulu(idx(j-askel)) <= taulu(apuidx)) EXIT
idx(j) = idx(j-askel)
j = j - askel
END DO
idx(j) = apuidx
END DO
241
IF (askel == 1) EXIT
END DO
END FUNCTION nousuindeksi
END MODULE nousu
Funktio nousuindeksi palauttaa tuloksen taulukossa idx. Shellsort-algoritmi on kohtalaisen nopea, vaikkakin isoille taulukoille (tuhansia alkioita) olisi
Quicksort-algoritmi luultavasti nopeampi.
Ohjelmakoodissa on kytetty Fortran 95:n ohjausrakenteita DO ... END DO
ja DO WHILE ... END DO sek EXIT-lausetta. Indeksitaulu idx alustetaan
kytten Fortranin taulukkoalustinta (/ ... /).
Olkoon lajiteltavana reaalilukutaulukko tiedot, jolloin nousuindeksin laskeminen ja lajittelu voitaisiin tehd seuraavasti:
! Otetaan kyttn lajittelufunktio:
USE nousu, ONLY : nousuindeksi
IMPLICIT NONE
REAL, DIMENSION(:), ALLOCATABLE :: tiedot
INTEGER, DIMENSION(:), ALLOCATABLE :: indeksit
INTEGER :: n, tila
READ (*,*) n
IF (n <= 1) THEN
STOP n <= 1
ELSE
ALLOCATE(tiedot(n), indeksit(n), STAT=tila)
IF (tila /= 0) THEN
STOP Virhe muistinvarauksessa!
END IF
CALL RANDOM_NUMBER(tiedot)
WRITE (*,(A,/,8(F9.5))) Data:, tiedot
indeksit = nousuindeksi(tiedot)
WRITE (*,(A,/,8(F9.5))) Lajiteltu data:, &
tiedot(indeksit)
END IF
Nousuindeksi lasketaan kokonaislukutaulukkoon indeksit:

indeksit = nousuindeksi(tiedot)
Lajiteltu taulukko voidaan tulostaa indeksoimalla taulukkoa tiedot indeksitaulukolla indeksit.

Koska nousuindeksi-funktiossa on kytetty epsuoraa indeksointia, on koodi tehottomampi kuin suoraviivainen Shellsort-algoritmin toteutus. Nousuindeksi voidaan kuitenkin kytt useamman taulukon lajitteluun yhteisen
lajittelukriteerin perusteella.
242
Fortran 95/2003
14.2.4 Monen taulukon lajittelu

Voimme kytt nousuindeksi lajittelemaan useampi taulukko yhteisen lajittelukriteerin mukaan. Seuraavassa on esimerkki vaikkapa moduuliin nousu
listtvst lajittelualiohjelmasta:
SUBROUTINE lajittele(taulu, lisataulu1, lisataulu2)
! Taulukkojen lajittelu indeksitaulun avulla
IMPLICIT NONE
REAL, DIMENSION(:), INTENT(INOUT) :: taulu
REAL, DIMENSION(:), INTENT(INOUT), OPTIONAL :: &
lisataulu1, lisataulu2
INTEGER, DIMENSION(SIZE(taulu)) :: indeksit
indeksit = nousuindeksi(taulu)
taulu = taulu(indeksit)
IF (PRESENT(lisataulu1)) THEN
IF (SIZE(taulu) /= SIZE(lisataulu1)) THEN
STOP Taulukot eri kokoiset!
ELSE
lisataulu1 = lisataulu1(indeksit)
END IF
END IF
IF (PRESENT(lisataulu2)) THEN
IF (SIZE(taulu) /= SIZE(lisataulu2)) THEN
STOP Taulukot eri kokoiset!
ELSE
lisataulu2 = lisataulu2(indeksit)
END IF
END IF
END SUBROUTINE lajittele
Aliohjelmassa lajittele lasketaan nousuindeksi taulukolle taulu, ja tmn jlkeen argumentti taulu lajitellaan nousuindeksin avulla. Jos aliohjelmalle lajittele on annettu valinnaiset (OPTIONAL) argumentit lisataulu1
tai lisataulu2, lajitellaan nm saman nousuindeksin avulla. Valinnaisten argumenttien antaminen aliohjelmakutsussa voidaan selvitt standardifunktion PRESENT avulla. Funktio SIZE palauttaa taulukon koon.
Voimme kytt tt lajittelualiohjelmaa esimerkiksi seuraavasti:
PROGRAM nousukas
USE nousu, ONLY : lajittele
IMPLICIT NONE
REAL, DIMENSION(100) :: d1, d2, d3
CALL RANDOM_NUMBER(d1)
d2 = 10.0 - d1
d3 = 2.0*(d1 - 0.5)
CALL lajittele(d1, d2, d3)
END PROGRAM nousukas
243
Tss lajittelemme taulukot d1, d2 ja d3 kytten lajittelujrjestyksen taulukkoa d1.
14.3
Sokkelon tekeminen
Tehtvn on luoda sokkeloruudukko, jossa on tsmlleen yksi reitti sokkelon lpi vasemmasta ylkulmasta oikeaan alakulmaan. Tehtv voidaan
jakaa seuraaviin osavaiheisiin:
1. kysytn halutun sokkelon kokoa ja alustetaan laskentatehtv
2. luodaan sokkelo
3. tulostetaan muodostettu sokkelo.
Sokkelo voidaan luoda ehk helpoiten kaksiulotteiseen kokonaislukutaulukkoon. Sokkelon tekemisess tarvittava tieto vapaista ja kussakin vaiheessa
kytetyist ruuduista sijoitetaan thn taulukkoon.
Seuraavassa esitetn runko sokkelon tekevlle ohjelmalle:
PROGRAM sokkelo
IMPLICIT NONE
INTEGER, DIMENSION(:,:), ALLOCATABLE :: taulu
INTEGER :: leveys, korkeus
Alustetaan tehtv
Luodaan sokkelo
Tulostetaan sokkelo
END PROGRAM sokkelo
Pohjelmassa mriteltiin globaalit nimet taulu, leveys ja korkeus.

Sokkelon alustamisen voi tehd seuraavalla aliohjelmalla:
SUBROUTINE alusta
IMPLICIT NONE
INTEGER :: tila
WRITE (*,*) Anna sokkelon leveys ja korkeus:
READ (*,*) leveys, korkeus
IF (leveys <= 1 .OR. korkeus <= 1) &
STOP Liian pieni sokkelo!
ALLOCATE(taulu(0:korkeus+1,0:leveys+1), STAT=tila)
IF (tila /= 0) STOP Muistinvaraus eponnistui!
taulu(1:korkeus,1:leveys) = tyhja
taulu(0,:) = reuna
taulu(korkeus+1,:) = reuna
taulu(:,0) = reuna
taulu(:,leveys+1) = reuna
Aliohjelmassa alusta kytetn pohjelman alussa mriteltvi globaaleja vakioita reuna ja tyhj, joiden arvot mrmme myhemmin.
244
Fortran 95/2003
Varsinaisen sokkelon luontiin ky seuraava itsen kutsuva aliohjelma:

RECURSIVE SUBROUTINE sijoita(k, l, n)
IMPLICIT NONE
INTEGER, INTENT(IN) :: k, l, n
taulu(k,l) = n
DO WHILE (.NOT. umpikuja(k,l))
SELECT CASE (arvaa(k,l))
CASE(alas)
CALL sijoita(k,l+1,n+1)
CASE(ylos)
CALL sijoita(k,l-1,n+1)
CASE(oikealle)
CALL sijoita(k+1,l,n+1)
CASE(vasemmalle)
CALL sijoita(k-1,l,n+1)
END SELECT
END DO
END SUBROUTINE sijoita
Aliohjelmassa tutkitaan, pstnk pisteest (k, l) kulkemaan eteenpin.

Tmn tarkistaa funktio umpikuja. Jos vapaita ruutuja lytyy taulukosta
taulu, valitsee funktio arvaa jonkin suunnan. Tt varten tytyy mritell
vaikkapa seuraavat arvot eri suuntia tarkoittaville vakioille ohjelmayksikn
alussa:
INTEGER, PARAMETER :: ylos = 1, alas = 2, &
oikealle = 3, vasemmalle = 4
Ohjelma siis simuloi diskreetti satunnaiskulkua (random walk) suorakulmaisessa hilassa. Umpikujaan joutumisen voi tarkistaa seuraavalla funktiolla:
LOGICAL FUNCTION umpikuja(k, l)
IMPLICIT NONE
INTEGER, INTENT(IN) :: k, l
umpikuja = taulu(k,l+1) /= tyhja .AND. &
taulu(k,l-1) /= tyhja .AND. &
taulu(k+1,l) /= tyhja .AND. &
taulu(k-1,l) /= tyhja
END FUNCTION umpikuja
Funktio umpikuja tarkistaa, onko taulukossa taulu vapaita viereisi ruutuja

vaaka- ja pystysuunnassa. Uuden suunnan voi tmn jlkeen valita seuraavasti:
INTEGER FUNCTION arvaa(k,l)
IMPLICIT NONE
INTEGER, INTENT(IN) :: k, l
INTEGER, DIMENSION(3) :: vapaat
REAL :: t
SELECT CASE (suuntia(vapaat,k,l))
CASE(1)
arvaa = vapaat(1)
CASE(2)
CALL RANDOM_NUMBER(t)
arvaa = vapaat(FLOOR(2*t+1))
245
CASE(3)
arvaa = vapaat(FLOOR(3*t+1))
END SELECT
END FUNCTION arvaa
Riippuen vapaiden suuntien mrst valitaan satunnaisesti niist jokin.

Tarvittavien satunnaislukujen tuottamiseen kytetn standardialiohjelmaa
RANDOM_NUMBER. Funktiossa arvaa kytetn apufunktiota suuntia vapaina
olevien suuntien lytmiseksi:
FUNCTION suuntia(vapaat,k,l) RESULT(i)
IMPLICIT NONE
INTEGER, DIMENSION(:), INTENT(INOUT) :: vapaat
INTEGER, INTENT(IN) :: k,l
INTEGER :: i
i = 0
IF (taulu(k,l+1) == tyhja) THEN
i = i + 1
vapaat(i) = alas
END IF
IF (taulu(k,l-1) == tyhja) THEN
i = i + 1
vapaat(i) = ylos
END IF
IF (taulu(k+1,l) == tyhja) THEN
i = i + 1
vapaat(i) = oikealle
END IF
IF (taulu(k-1,l) == tyhja) THEN
i = i + 1
vapaat(i) = vasemmalle
END IF
END FUNCTION suuntia
Nyt meill onkin mriteltyn valmis sokkelonteko-ohjelma lukuunottamatta tulostusproseduuria. Voimme simuloida tulostusta aluksi seuraavalla yksinkertaisella aliohjelmalla:
SUBROUTINE tulosta
IMPLICIT NONE
INTEGER :: k
DO k = 1, korkeus
WRITE (*,(24(I3))) taulu(k,1:leveys)
END DO
Pohjelma tytyy kirjoittaa vaikkapa seuraavan nkiseksi:

PROGRAM sokkelo
IMPLICIT NONE
INTEGER, PARAMETER :: alku = 1, tyhja = alku - 1, &
reuna = tyhja - 1
INTEGER, PARAMETER :: ylos = 1, alas = 2, &
oikealle = 3, vasemmalle = 4
INTEGER, DIMENSION(:,:), ALLOCATABLE :: taulu
INTEGER :: leveys, korkeus
246
Fortran 95/2003
CALL alusta
CALL sijoita(1,1,alku)
CALL tulosta
CONTAINS
Proseduurit alusta, sijoita, umpikuja, arvaa,
suuntia ja tulosta
END PROGRAM sokkelo
Aliohjelmakutsu
CALL sijoita(1,1,alku)
aloittaa sokkelon luomisen kokonaislukutaulukon taulu vasemmasta ylkulmasta. Ohjelman tulostus voisi olla seuraavaa:
Anna sokkelon leveys
10 5
1 4 5 34 33 32 31
2 3 6 19 20 33 34
9 8 7 18 21 26 27
10 13 14 17 22 25 42
11 12 15 16 23 24 43
ja korkeus:
30
29
28
41
40
31
34
35
38
39
32
33
36
37
40
Sokkelon ratkaisureitti kulkee vasemmasta ylkulmasta oikeaan alakulmaan

seuraamalla kasvavaa lukujonoa 1, 2, 3, . . . , 39, 40.
Haluamme tulostaa sokkelon hiukan visuaalisemmassa muodossa. Tmn
voi tehd seuraavan aliohjelman avulla:
SUBROUTINE tulosta
IMPLICIT NONE
CHARACTER, PARAMETER :: pystyaita = !, &
vaaka_aita = -, kulmaus = +, vali =
CHARACTER(LEN=1), DIMENSION(:,:), ALLOCATABLE :: &
merkkitaulu
INTEGER :: tila, k, l, mk, ml, i, j
k = korkeus
l = leveys
mk = 2*k
ml = 2*l
ALLOCATE(merkkitaulu(0:mk,0:ml), STAT=tila)
IF (tila /= 0) STOP Muistinvaraus eponnistui!
merkkitaulu(1:mk-1:2,1:ml-1:2) = vali
merkkitaulu(::2,::2) = kulmaus
merkkitaulu(1:mk-1:2,::2) = pystyaita
merkkitaulu(::2,1:ml-1:2) = vaaka_aita
WHERE (ABS(taulu(1:k-1,1:l)-taulu(2:k,1:l)) == 1)
END WHERE
WHERE (ABS(taulu(1:k,1:l-1)-taulu(1:k,2:l)) == 1)
END WHERE
merkkitaulu(0,1) = vali
merkkitaulu(mk,ml-1) = vali
DO i = 0, mk
DO j = 0, ml-1
247
WRITE (*,(A),ADVANCE=NO) merkkitaulu(i,j)

END DO
WRITE (*,(A)) merkkitaulu(i,ml)
END DO
DEALLOCATE(merkkitaulu)
Tulostusproseduurissa luodaan sokkelon mrittelev merkkityypin taulukko merkkitaulu kyttmll taulukkonotaatiota. Tulostus tehdn riveittin.
Seuraavassa ohjelman kyttesimerkki:
Anna sokkelon leveys ja korkeus:
10 5
+ +-+-+-+-+-+-+-+-+-+
! !
!
!
+ + + +-+-+ +-+ +-+ +
!
! !
!
! !
!
+-+-+ + + +-+-+ + +-+
!
! ! !
!
!
+ +-+-+ + + +-+-+-+ +
! !
! ! ! !
!
!
+ + + + + + + + + +-+
!
!
!
! !
!
+-+-+-+-+-+-+-+-+-+ +
Tss tulostettiin sama sokkelo, joka esitettiin aiemmin kokonaislukutaulukkona. Ohjelmaa on kytetty mys tulostamaan tmn kirjan kansikuva.
14.4
Yksiulotteinen soluautomaatti
Soluautomaatit (cellular automata) ovat diskreettej dynaamisia systeemej,

jotka vaihtavat tilaansa synkronisesti. Useimmat soluautomaatit ovat lhes
tydellisen rinnakkaisia algoritmeja. Niiden toteuttaminen Fortranin taulukko-operaatioilla onnistuu helposti.
14.4.1 Soluautomaattien mrittely

Yksiulotteinen soluautomaatti koostuu jonosta soluja x(i), joista kullakin
on vasemman- ja oikeanpuoleinen naapurisolu x(i 1) ja x(i + 1). Olkoon
solujen lukumr n. Soluautomaattimme on periodinen, jos solun x(n)
oikea naapuri on solu x(1) ja solun x(1) vasen naapuri on solu x(n).
Edellisess tapauksessa kullakin solulla oli vain yksi naapuri kummallakin
puolellaan. Tllin sanotaan, ett naapuriston sde r on yksi. Yleisemmss
tapauksessa voimme ajatella, ett kunkin solun tilaan vaikuttaa useampi
kuin yksi naapuri, jolloin sde r on suurempi kuin yksi.
Solu x(i) saa arvoja diskreetist joukosta {0, 1, 2, . . . , k 1}. Arvojen lukumr k voi olla esimerkiksi 2, jolloin soluautomaatti on binrinen eli
248
Fortran 95/2003
tilajoukko on {0, 1}.

Kaikki soluautomaatin solut muuttavat tilaansa x(i) synkronisesti. Soluautomaatin (r = 1, k = 2) muutossnt voisi olla esimerkiksi seuraava: jos
solujen {x(i 1), x(i), x(i + 1)} (eli naapuriston) arvojen summa on 1, arvo
seuraavalla ajanhetkell on 1. Muussa tapauksessa arvo on 0.
Edell kuvattua soluautomaattia sanotaan totalistiseksi. Tllaisen soluautomaatin snt riippuu vain naapurisolujen arvojen summasta. Totalistisen
(r , k)-soluautomaatin soluympristn arvojen summa voi saada yhteens
(k 1)(2r + 1) + 1 eri arvoa. Tapauksessa (r = 1, k = 2) arvoja on nelj: 0,
1, 2 ja 3.
Soluautomaatin tilamuutosta kuvaava funktio voidaan totalistisen soluautomaatin tapauksessa kuvata taulukkona, jossa on (k 1)(2r + 1) + 1 alkiota.
Erilaisten funktioiden lukumr on k(k1)(2r +1)+1 .
Esimerkiksi totalistisia (r = 1, k = 2)-soluautomaatteja on 24 = 16 erilaista. Kukin tllainen soluautomaatti voidaan kuvata neljn merkin mittaisena
binrilukuna. Esimerkiksi soluautomaatti 0010 tuottaa arvon yksi silloin,
kun tilojen summa on yksi. Nm binriluvut voidaan muuntaa desimaalijrjestelmn, jolloin soluautomaatit saadaan numeroitua (numerot 0 . . . 15).
Esimerkkinmme olleen soluautomaatin jrjestysnumero on siis 2.
14.4.2 Soluautomaatin toteutus

Toteutamme seuraavassa moduulin ca1d, jossa on julkiset (PUBLIC) proseduurit ca_init ja ca_table soluautomaattihilan alustamiseen ja soluautomaatin simuloimiseen. Moduulin sisiset muuttujat ja tyypinmrittelyt
eivt ny ulkopuolelle.
Moduulin runko nytt seuraavalta:
MODULE ca1d
IMPLICIT NONE
PUBLIC :: ca_init, ca_table
PRIVATE
INTEGER, PARAMETER :: short = SELECTED_INT_KIND(2), &
long = SELECTED_INT_KIND(9)
TYPE ca_rule_type
INTEGER(KIND=short) :: k, r
INTEGER(KIND=long) :: rule_nr
INTEGER(KIND=short), DIMENSION(:), POINTER :: table
END TYPE ca_rule_type
CONTAINS
Funktioiden ca_init ja ca_table mrittely
END MODULE ca1d
Mrittelimme moduulin sisiseen kyttn tietotyypin ca_rule_type, jonka taulukkoon table voimme sijoittaa soluautomaatin snttaulukon. Soluautomaatin alustamisen voisi tehd seuraavasti:
FUNCTION ca_init(n, k) RESULT(res)
IMPLICIT NONE
249
INTEGER, INTENT(IN) :: n, k
INTEGER, DIMENSION(n) :: res
res = k*t
END FUNCTION ca_init
Tmn funktion palauttama arvo on yksiulotteinen taulukko, jonka pituus

on n ja jonka arvot ovat kokonaislukuja vlilt [0, k 1]. Arvot lasketaan
standardialiohjelman RANDOM_NUMBER avulla.
Soluautomaatin simuloimisen voisimme toteuttaa seuraavasti:
FUNCTION ca_table(config, k, r, nr, iter) RESULT(res)
IMPLICIT NONE
INTEGER, DIMENSION(:), INTENT(IN) :: config
INTEGER, INTENT(IN) :: k, r, nr, iter
INTEGER, DIMENSION(SIZE(config),0:iter) :: res
TYPE(ca_rule_type) :: rule
INTEGER :: i
rule = ca_rule(k, r, nr)
res(:,0) = config
DO i = 1, iter
res(:,i) = ca_value(res(:,i-1))
END DO
CONTAINS
Funktion ca_value mrittely
END FUNCTION ca_table
Funktiossa ca_table kytettiin funktiota ca_rule laskemaan soluautomaatin snt taulukkoon rule, joka on tyyppi ca_rule_type. Sisisell funktiolla ca_value puolestaan lasketaan soluautomaattihilan arvo seuraavalla
ajanhetkell. Tmn voisi toteuttaa seuraavasti:
FUNCTION ca_value(config) RESULT(res)
IMPLICIT NONE
INTEGER, DIMENSION(SIZE(config)) :: res
INTEGER :: r, k, n, i
r = rule % r
k = rule % k
n = SIZE(config)
res = 0
DO i = -r, r
res = res + CSHIFT(config,i)
END DO
res = rule % table(res+1)
END FUNCTION ca_value
Funktiossa kytetn isntproseduurista ca_table perisin olevan rulemuuttujan arvoa. Rakenteisen muuttujan komponentteihin viitataan prosenttimerkin avulla: rule%r, rule%k ja rule%table.
Funktiossa ca_value lasketaan rinnakkain soluautomaattihilan uudet arvot. Muuttuja res on taulukko, ja lauseessa res = 0 asetetaan taulukon
kaikki alkiot nolliksi. Kaikkien naapuristojen alkioiden summat lasketaan
250
Fortran 95/2003
kyttmll apuna CSHIFT-funktiota, joka siirt taulukkoa config halutun

mrn askeleita. Lauseessa
res = res + CSHIFT(config,i)
listn siten res-taulukon alkioihin config-taulukon alkiot siirrettyin periodisesti i askelta. Lopulliset soluautomaattihilan arvot saadaan indeksoimalla taulukkoa rule%table seuraavaan tapaan:
res(i) = rule % table(res(i)+1)
Tss lauseessa tehdn sijoitus res-taulukon yhdelle alkiolle. Funktiossa

ca_value kytetn taulukkosyntaksia ja tehdn sijoitus kaikille alkioille
yht aikaa:
En tarvitsee toteuttaa snttaulukon laskeva funktio ca_rule:

FUNCTION ca_rule(k, r, nr) RESULT(res)
IMPLICIT NONE
INTEGER, INTENT(IN) :: k, r, nr
TYPE(ca_rule_type) :: res
res % k = k
res % r = r
res % rule_nr = nr
CALL totalistic_rule_table
CONTAINS
SUBROUTINE totalistic_rule_table
IMPLICIT NONE
INTEGER :: allocstat, n, i
n = (k-1)*(2*r+1) + 1
ALLOCATE(res % table(n), STAT=allocstat)
IF (allocstat /= 0) STOP allocation failed!
res % table = (/ (rule_value(i,nr,k), i = 1, n) /)
END SUBROUTINE totalistic_rule_table
RECURSIVE FUNCTION rule_value(b, r, k) RESULT(value)
IMPLICIT NONE
INTEGER, INTENT(IN) :: b, r
INTEGER, INTENT(IN) :: k
INTEGER :: value
IF (b == 1) THEN
value = MOD(r,k)
ELSE
value = rule_value(b-1, r/k, k)
END IF
END FUNCTION rule_value
END FUNCTION ca_rule
Funktio palauttaa tyyppi ca_rule_type olevan tuloksen muuttujassa res.

Soluautomaattisnnn taulukolle varataan tilaa ALLOCATE-kskyll, jonka
jlkeen taulukon res%table kuhunkin alkioon lasketaan soluautomaattisnt vastaava arvo. Apuna kytetn rekursiivista funktiota rule_value.
Tm funktio tekee itse asiassa muunnoksia desimaalijrjestelmst k-kantaiseen lukujrjestelmn.
251
14.4.3 Kyttesimerkki
Kytmme moduulia ca1d soluautomaattien havainnollistukseen:
PROGRAM ca1dtest
USE ca1d, ONLY : ca_init, ca_table
IMPLICIT NONE
INTEGER, DIMENSION(:,:), ALLOCATABLE :: table
INTEGER, DIMENSION(:), ALLOCATABLE :: init
INTEGER :: nr, k, r, t, n, iter, i
WRITE (*,*) Anna nr, k, r:
READ (*,*) nr, k, r
WRITE (*,*) Pituus ja iter. lkm:
READ (*,*) n, iter
ALLOCATE(table(n,0:iter), init(n))
init = ca_init(n, k)
table = ca_table(init, k, r, nr, iter)
DO i = 0, iter
WRITE (*,(35I2))) table(:,i)
END DO
END PROGRAM ca1dtest
Ohjelman toiminta nytt seuraavalta:

Anna nr, k, r:
2 2 1
Pituus ja iter.
24 6
0 0 0 1 1 1 0 1
1 0 1 0 0 0 0 0
...
0 1 1 1 0 1 0 0
lkm:
1 1 0 1 0 1 1 1 0 0 1 0 0 0 1 1
0 0 0 1 0 0 0 0 1 1 1 1 0 1 0 0
1 0 0 1 0 0 1 1 0 0 1 0 0 1 1 1
Tulostimme soluautomaatin (k = 2, r = 1) (sntnumero 2) tilojen kehityksen riveittin, ylimpn on satunnainen alkutila.
14.4.4 Tulostus PGM-muodossa

Edell kytetty tekstimuotoinen tulostus ei ole kovin havainnollista. Voimme tulostaa datan harmaasvykuvana kyttmll PGM-formaattia (portable
graymap).
Seuraavassa on thn soveltuva aliohjelma:
SUBROUTINE write_pgm(filename, table)
IMPLICIT NONE
CHARACTER(LEN=*), INTENT(IN) :: filename
INTEGER, DIMENSION(:,:), INTENT(IN) :: table
INTEGER :: m, n, minim
INTEGER, PARAMETER :: io_unit = 1
OPEN (io_unit, file=filename)
minim = MINVAL(table)
WRITE (io_unit, (A)) P2
252
Fortran 95/2003
WRITE (io_unit, (A)) # // filename

m = SIZE(table,1)
n = SIZE(table,2)
WRITE (io_unit, (2I6,/,I4)) m, n, MAXVAL(table)-minim
WRITE (io_unit, (16I4)) table-minim
END SUBROUTINE write_pgm
PGM-tiedoston kaksi ensimmist merkki ovat P2. Tmn jlkeen tulee kuvan dimensiot sek datassa esiintyv maksimiarvo. Tulostusksky voisi nytt seuraavalta:
CALL write_pgm(ca1d.pgm, table)
Esimerkiksi edellisess tapauksessa tulostus voisi olla seuraavan nkist:

P2
# ca1d.pgm
24
7
1
0
0
0
0
0
1
1
0
1
0
1
0
0
1
1
1
1
1
1
0
0 ...
1 ...
Tss kuvan koko on 24 7 pikseli ja maksimiarvo on 1. Merkill # alkava

rivi tulkitaan kommentiksi.
PGM-tiedostoja voi lukea Unix-ympristss esimerkiksi xv-ohjelmistolla,
jolla ne voi mys muuntaa esimerkiksi PostScript-muotoon. Tulos voisi nytt seuraavalta:
Tss hilan pituus oli 240 ja soluautomaattia iteroitiin 100 kertaa. Tilat on
esitetty riveittin, ylimpn on alkutila.
PGM-formaatin sijaan voi kytt PPM-formaattia (portable pixmap), jossa
voi esitt vrillist dataa.
14.4.5 Taulukkosyntaksin mahdollisuuksia

Edell laskimme soluautomaattihilan tilan seuraavalla ajanhetkell kytten
funktiota ca_value. Arvo laskettiin DO-silmukassa, jota toistettiin 2r + 1
kertaa. Tmn funktion voisi toteuttaa toisellakin tavalla:
FUNCTION ca_value(config) RESULT(res)
IMPLICIT NONE
INTEGER, DIMENSION(SIZE(config)) :: res
INTEGER :: r, k, n, i
253
r = rule % r
k = rule % k
n = SIZE(config)
res = SUM( CSHIFT( SPREAD(config, DIM=2, ncopies=2*r+1), &
shift=(/(i, i = -r, r)/), DIM=1), DIM=2)
END FUNCTION ca_value
Tss selvimme taulukkosyntaksilla, yhtn silmukkaa ei tarvita. Ongelmaksi voisi muodostua muistinkytt, sill funktio SPREAD tuottaa taulukon,
jonka koko on n(2r + 1). Toisaalta useimmiten sde r on paljon pienempi
kuin hilan pituus n, joten tm ei ole ongelma. Tmn koodin luettavuus ei
kuitenkaan ole yht hyv kuin aiemman silmukkaversion.
14.4.6 Listietoa
Soluautomaateista kerrotaan mm. teoksissa Theory and Applications of Cellular Automata (Stephen Wolfram, World Scientic, 1986) ja A New Kind of
Science (Stephen Wolfram, Wolfram Media, 2002). CSC on julkaissut teoksen
Workshop on Cellular Automata, Proceedings (toim. Juha Haataja, 1991).
14.5
Life-soluautomaatti
Life-soluautomaatti eli Life-peli koostuu kaksiulotteiseen suorakulmaiseen

hilaan sijoitetuista soluista. Kunkin solun naapureiksi lasketaan kahdeksan lhint solua. Solulla on kaksi tilaa: elossa ja kuollut. Kaikki solut
muuttavat tilojaan yht aikaa seuraavia sntj noudattamalla:
jos tyhjn solun naapureista on kolme elossa, naapuriston keskelle syntyy uusi solu
jos naapureista on kaksi tai kolme elossa, vanha solu silyy hengiss
muussa tapauksessa elossa oleva solu kuolee joko yksinisyyteen tai
liikakansoitukseen.
Seuraavassa pohjelmassa on mritelty Life-soluautomaattia simuloivan
ohjelman rakenne. Solujen tilat talletetaan kokonaislukutaulukoihin lauta_1
ja lauta_2.
PROGRAM Life
IMPLICIT NONE
CHARACTER (LEN=*), PARAMETER :: tiedosto = life.dat
INTEGER, PARAMETER :: maksimikoko = 200
INTEGER, DIMENSION(:,:), POINTER :: lauta_1, lauta_2
INTEGER :: leveys = 20, korkeus = 20, toistot = 1000, iter
CALL lue_lauta
CALL pyyhi
254
Fortran 95/2003
DO iter = 1, toistot/2
CALL piirra(lauta_1,lauta_2)
CALL laske(lauta_1,lauta_2)
END DO
IF (MOD(toistot,2) == 1) THEN
END IF
CALL pyyhi
CONTAINS
Aliohjelmat lue_lauta, pyyhi, piirra ja laske
END PROGRAM Life
Aliohjelma lue_lauta lukee toistokertojen eli sukupolvien lukumrn,

pelilaudan koon ja alkukonguraation tiedostosta. Ohjelmassa kytetn
taulukkoja lauta_1 ja lauta_2 Life-pelin nykyisen ja seuraavan tilan tallentamiseen. Lautoja kytetn vuorotellen, joten DO-silmukassa tehdn
yhdell kierroksella kaksi Life-pelin iteraatiota.
Pelilaudan sislt voidaan lukea tiedostosta seuraavasti:
SUBROUTINE lue_lauta
IMPLICIT NONE
INTEGER :: i, j
CHARACTER(LEN=maksimikoko) :: rivi
NAMELIST / lista / toistot, leveys, korkeus
OPEN (1, FILE=tiedosto, STATUS=OLD, ACTION=READ, &
FORM=FORMATTED)
READ (1, NML=lista)
IF (toistot < 1) STOP Iteraatioiden maksimimr &
&nolla tai negatiivinen!
IF (leveys < 1 .OR. korkeus < 1 .OR. &
leveys > maksimikoko) THEN
STOP Liian pieni tai iso lauta!
END IF
ALLOCATE (lauta_1(korkeus,leveys))
lauta_1 = 0
DO i = 1, korkeus
READ(1,(A),END=99) rivi
DO j = 1, leveys
IF (rivi(j:j) /= ) lauta_1(i,j) = 1
END DO
END DO
99 CLOSE(1)
ALLOCATE (lauta_2(SIZE(lauta_1,1),SIZE(lauta_1,2)))
lauta_2(:,:) = 0
END SUBROUTINE lue_lauta
Toistokertojen lukumrn sek laudan leveyden ja korkeuden lukemiseen

kytetn NAMELIST-ryhm lista.
Aliohjelma pyyhi voisi olla seuraava:
255
SUBROUTINE pyyhi
WRITE (*,(A)) CHAR(27) // [2J
END SUBROUTINE pyyhi
Tss kytetn VT100-tekstiptteen ohjauskoodeja, ja tulostettu koodi

tyhjent ruudun sislln (CHAR(27) on Esc -merkki).
Life-pelin seuraava sukupolvi voidaan laskea kyttmll taulukkosyntaksia. Tss kytetn periodisia reunaehtoja, jolloin taulukon vasen reuna on
oikean reunan naapuri ja ylreuna on alareunan naapuri.
SUBROUTINE laske(lauta_1,lauta_2)
IMPLICIT NONE
INTEGER, DIMENSION(SIZE(lauta_1,1),SIZE(lauta_1,2)) :: &
summa
summa = CSHIFT (lauta_1, shift= 1, DIM=1) + &
CSHIFT (lauta_1, shift=-1, DIM=1) + &
CSHIFT (lauta_1, shift= 1, DIM=2) + &
CSHIFT (lauta_1, shift=-1, DIM=2) + &
CSHIFT (CSHIFT (lauta_1, shift= 1, DIM=2),
shift= 1, DIM=1) + &
CSHIFT (CSHIFT (lauta_1, shift= 1, DIM=2),
shift=-1, DIM=1) + &
CSHIFT (CSHIFT (lauta_1, shift=-1, DIM=2),
shift= 1, DIM=1) + &
CSHIFT (CSHIFT (lauta_1, shift=-1, DIM=2),
shift=-1, DIM=1)
WHERE (summa < 2 .OR. summa > 3)
lauta_2 = 0
ELSEWHERE
lauta_2 = lauta_1
END WHERE
WHERE (summa == 3) lauta_2 = 1
END SUBROUTINE laske
&
&
&
&
Peliss tapahtuneet muutokset voidaan piirt kytten VT100-ptteen ohjauskoodeja. Aliohjelmassa piirra kytetn kappaleessa 9.13.2 sivulla 144
esitelty muotoiluoperaattoria .fmt., jolloin tulostettavan merkin rivi ja
saraketta kuvaavat luvut saadaan tulostettua tsmlleen oikean kokoisiin
kenttiin. Aliohjelman muodollinen argumentti lauta_1 on Life-pelin uusi
tilanne ja lauta_2 vanha tilanne.
SUBROUTINE piirra(lauta_1,lauta_2)
USE muotoilu ! Kytetn operaattoria ".fmt."
IMPLICIT NONE
CHARACTER(LEN=*), PARAMETER :: escape = CHAR(27) // [
INTEGER :: i, j
DO i = 1, SIZE(lauta_1,1)
DO j = 1, SIZE(lauta_1,2)
IF (lauta_1(i,j) /= lauta_2(i,j)) THEN
WRITE (*,(A),ADVANCE=NO) escape
WRITE (*,( // .fmt. i // ,A), &
256
Fortran 95/2003
ADVANCE=NO) i, ;
WRITE (*,( // .fmt. (j-1) // ,A), &
ADVANCE=NO) j-1, H
IF (lauta_1(i,j) /= 0) THEN
WRITE (*,(A),ADVANCE=NO) *
ELSE
WRITE (*,(A),ADVANCE=NO)
END IF
END IF
END DO
END DO
IF (lauta_1(1,1) /= 0) THEN
WRITE (*,(A)) escape // 1;0H*
ELSE
WRITE (*,(A)) escape // 1;0H
END IF
END SUBROUTINE piirra
Aliohjelmassa piirretn vain muuttuneet solut, joten ohjelman tulostus on

nopeaa. Tulostuksen lopussa siirretn osoitin ruudun ylkulmaan.
Seuraavassa on esimerkki ohjelman sytttiedostosta (tiedoston alussa sytetn NAMELIST-ryhm lista):
&lista toistot = 300, leveys = 40, korkeus = 20 /
*
* ***
*
*
***
*
Tuloksena lasketaan 300 toistokertaa 40 20 -kokoisella laudalla. Seuraavassa on kuuden ensimmisen iteraatioaskeleen tilanteet (vain laudan vasemman ylkulman tilanne on esitetty).
*
**
**
*
***
**
*
**
***
* *
* **
**
14.6
*
* *
*
**
* *
* *
**
**
* *
***
*
**
*** * *
*
* * *
* **
*
***
**
**
* **
* *
**
***
***
*
*
**
****
*
*
* *
*
**
*
*
*
* *
*
Binripuu
Binripuu on yksinkertainen mutta tehokas dynaaminen tietorakenne, jota

voidaan kytt esimerkiksi tiedon jrjestmiseen puumaiseksi rakenteeksi.
257
Tst rakenteesta tieto on yleens haettavissa nopeammin kuin esimerkiksi

yksinkertaisesta listasta tai taulukosta.
Seuraavassa mriteltvn binripuun solmuun puu sisltyy hakuavain, siihen liittyv tieto sek osoittimet vasempaan ja oikeaan alipuuhun:
TYPE puu
CHARACTER(LEN=avain_pituus) :: avain
CHARACTER(LEN=tiedon_pituus) :: tieto
TYPE(puu), POINTER :: vasen, oikea
END TYPE puu
Hakuavain on tss merkkijono (esimerkiksi puhelinnumero), jonka mukaan

tieto (esimerkiksi puhelimen omistajan nimi) on puussa jrjestetty ja jonka
mukaan tietoa etsitn.
Puun vasempaan haaraan laitetaan kaikki ne avaimet, jotka tulevat lajittelujrjestyksess ennen kyseisen solmun avainta. Vastaavasti oikeassa haarassa ovat lajittelujrjestyksess myhemmt avaimet.
Puuta luotaessa tehdn aluksi juurisolmu, jossa on aakkosten alussa oleva
merkkijono. Tllin siis hakualgoritmissa siirrytn aina oikeaan alipuuhun.
Aluksi oikeassa alipuussa on vain loppumerkki loppu, jonka alipuut viittaavat solmuun itseens.
Kun puuhun sytetn uusia avain-tieto -pareja, avainkentt verrataan nykyisen solmun avainkenttn ja siirrytn joko vasempaan tai oikeaan alipuuhun. Nin jatketaan kunnes trmtn solmuun loppu, jota ennen luodaan uusi solmu.
Etsint varten loppusolmun avainkentksi laitetaan etsittv avain ja loppusolmun tietokentksi teksti Ei lytynyt. Siten etsinnss lytyy aina
jokin solmu, jonka avain vastaa etsittv avainta. Jos avainta ei lytynyt
puusta, palautetaan loppusolmun tietokentt merkkin virheest.
Jos binripuussa on n solmua, alkio lytyy parhaassa tapauksessa log2 n
askeleella. Tm edellytt, ett puu on tasapainoitettu, eli ett syttvaiheessa avaimet ovat olleet satunnaisessa jrjestyksess, jolloin solmuissa
kytetn yht paljon vasempia ja oikeita alipuita. Jos sen sijaan avaimet
sytetn valmiiksi aakkosjrjestyksess, kytetn pelkstn oikeapuoleisia alipuita ja haku kest n askelta.
Kyttmmme binripuun toteuttava algoritmi on perisin kirjasta Algorithms [Sed84]. Moduuli noudattaa tietoabstraktion periaatteita, joiden mukaan tietotyyppi ja sit ksittelevt proseduurit on liitetty yhteen, eik niiden
toteutus ny kutsuvalle pohjelmalle.
MODULE bpuu
! Moduulissa toteutetaan lisys ja etsint binripuussa
IMPLICIT NONE
PRIVATE
INTEGER, PARAMETER :: avain_pituus = 4, &
tiedon_pituus = 30
TYPE puu
258
Fortran 95/2003
TYPE(puu), POINTER :: vasen, oikea

END TYPE puu
TYPE(puu), POINTER :: juuri, loppu
CHARACTER(LEN=avain_pituus), PARAMETER :: pienin_avain =
CHARACTER(LEN=*), PARAMETER :: puu_ei_loydy = Ei lytynyt
PUBLIC :: avain_pituus, tiedon_pituus, etsi, syota, &
alusta_puu, tulosta_puu
CONTAINS
SUBROUTINE alusta_puu()
! Tm aliohjelma alustaa binripuun juuren sek
! loppumerkin.
! Juuressa avain on pienin_avain, loppumerkin
! osoittimet osoittavat loppumerkkiin.
ALLOCATE(juuri, loppu)
juuri%avain = pienin_avain
juuri%oikea => loppu
loppu%tieto = puu_ei_loydy
loppu%vasen => loppu
loppu%oikea => loppu
END SUBROUTINE alusta_puu
FUNCTION etsi (avain) RESULT(tieto)
! Tm aliohjelma etsii avainta taulukosta ja palauttaa
! tieto-alkion.
IMPLICIT NONE
CHARACTER(LEN=avain_pituus), INTENT(IN) :: avain
TYPE(puu), POINTER :: mina
mina => juuri%oikea
loppu%avain = avain
DO WHILE (avain /= mina%avain)
IF (avain < mina%avain) THEN
mina => mina%vasen
ELSE
mina => mina%oikea
END IF
END DO
tieto = mina%tieto
END FUNCTION etsi
SUBROUTINE syota(avain, tieto)
! Tm aliohjelma tekee puuhun uuden solmun, jonka
! tunnukset ovat avain ja tieto.
IMPLICIT NONE
CHARACTER(LEN=*), INTENT(IN) :: avain
CHARACTER(LEN=*), INTENT(IN) :: tieto
TYPE(puu), POINTER :: isa, mina
isa => juuri
mina => juuri%oikea
DO WHILE (.NOT. ASSOCIATED(mina, loppu))
isa => mina
IF (avain < mina%avain) THEN
mina => mina%vasen
259
ELSE
mina => mina%oikea
END IF
END DO
ALLOCATE(mina)
mina%avain = avain
mina%tieto = tieto
mina%vasen => loppu
mina%oikea => loppu
IF (avain < isa%avain) THEN
isa%vasen => mina
ELSE
isa%oikea => mina
END IF
END SUBROUTINE syota
SUBROUTINE tulosta_puu()
! Tm on pllystakki tulostusaliohjelmalle
WRITE (*,*) Listaus tiedoista puurakenteen &
&mukaan sisennettyin:
CALL tulosta_sisainen(juuri%oikea, 1)
END SUBROUTINE tulosta_puu
RECURSIVE SUBROUTINE tulosta_sisainen(mina, taso)
! Tm aliohjelma tulostaa rekursiivisesti puun
IMPLICIT NONE
TYPE(puu), POINTER :: mina
INTEGER, INTENT(IN) :: taso
IF (.NOT. ASSOCIATED(mina, loppu)) THEN
CALL tulosta_sisainen(mina%vasen, taso+1)
WRITE (*,*) REPEAT( ,2*taso), mina%avain, mina%tieto
CALL tulosta_sisainen(mina%oikea, taso+1)
END IF
END SUBROUTINE tulosta_sisainen
END MODULE bpuu
Seuraava pohjelma alustaa binripuun, lukee ptteelt avaimia ja tietoalkioita ja lis ne puuhun. Sen jlkeen tulostetaan puu. Viimeinen silmukka kysyy kyttjlt avainkentti ja hakee puusta vastaavan tietokentn. Jos avainta ei lydy puusta, algoritmi palauttaa loppu-solmussa olevan
virheilmoituksen.
PROGRAM puut
USE bpuu
IMPLICIT NONE
CALL alusta_puu()
tiedon_luku: DO
WRITE (*, (A), ADVANCE = NO) Syt avain &
&(tyhj lopettaa):
READ(*, (A)) avain
260
Fortran 95/2003
IF (avain == ) EXIT tiedon_luku

WRITE (*, (A), ADVANCE = NO) Syt tieto:
READ (*, (A)) tieto
CALL syota(avain, tieto)
END DO tiedon_luku
CALL tulosta_puu
tiedon_haku: DO
WRITE (*, (A), advance = no) Syt avain &
&(tyhj lopettaa):
READ (*, (A)) avain
IF (avain == ) EXIT tiedon_haku
WRITE (*, *) Tieto on: , etsi(avain)
END DO tiedon_haku
END PROGRAM puut
Seuraavassa ohjelman esimerkkiajossa kytetn sytteen teleliikennealueiden suuntanumeroita ja nimi:

Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
Syt
avain (tyhj lopettaa):

tieto: Ahvenanmaa
tieto: Keski-Suomi
tieto: Lappi
tieto: Pohjois-Karjala
tieto: Uusimaa II
tieto: Hme
tieto: Kuopio
tieto: Mikkeli
tieto: Turku ja Pori
tieto: Vaasa
tieto: Kymi
tieto: Oulu
tieto: Uusimaa I
018
014
016
013
019
03
017
015
02
06
05
08
09
Listaus tiedoista puurakenteen mukaan sisennettyin:

013 Pohjois-Karjala
014 Keski-Suomi
015 Mikkeli
016 Lappi
017 Kuopio
018 Ahvenanmaa
019 Uusimaa II
261
02
03
Turku ja Pori
Hme
05 Kymi
06 Vaasa
08 Oulu
09 Uusimaa I
Syt avain (tyhj lopettaa): 019

Tieto on: Uusimaa II
Tieto on: Uusimaa I
Tieto on: Ei lytynyt
Syt avain (tyhj lopettaa):
14.7
Sukupuu
Sukupuun esittmiseen ei edell kytetty binripuu sovi, koska vanhemmilla voi olla nolla, yksi tai useampi jlkelist. Tarvitaan siis uudenlainen listarakenne. Seuraava moduuli toteuttaa sukupuutyypin sek proseduurit sukutiedon lukemiseen ja tulostamiseen. Moduulissa on mritelty tietotyyppi
perhe, joka sislt vanhempien nimet ja syntymajat, lasten lukumrn
sek osoittimet lapsiin.
Lapsien esittmist varten tarvitaan taulukko lapset, jonka alkiot sisltvt osoitinmuuttujan perhe-tietotyyppiin. Ohjelmassa viitataan muuttujan
mina lapseen numero i rakenteella
mina%lapset(i)%p
Tss p on tietotyypin perheosoitin ainoa komponentti, joka osoittaa lapsen perhe-tietorakenteeseen.

MODULE sukupuu
IMPLICIT NONE
TYPE perheosoitin
TYPE (perhe), POINTER :: p
END TYPE perheosoitin
TYPE perhe
CHARACTER (LEN=30) :: nimi
CHARACTER (LEN=10) :: synt_aika
CHARACTER (LEN=30) :: puoliso
CHARACTER (LEN=10) :: puol_synt_aika
INTEGER :: lapsia
TYPE (perheosoitin), POINTER :: lapset(:)
END TYPE perhe
CONTAINS
RECURSIVE FUNCTION lue() RESULT (mina)
! Tm funktio lukee perheen tiedot ja kutsuu
! lukufunktiota rekursiivisesti kaikille lapsille.
! Funktio palauttaa osoittimen perheeseen.
IMPLICIT NONE
262
Fortran 95/2003
TYPE(perhe), POINTER :: mina

INTEGER :: i
ALLOCATE(mina)
WRITE (*,(A),ADVANCE=NO) Anna nimi:
READ (*,(A)) mina%nimi
WRITE (*,(A),ADVANCE=NO) Anna syntymaika:
READ (*,(A)) mina%synt_aika
WRITE (*,(A),ADVANCE=NO) Anna puolison nimi:
READ (*,(A)) mina%puoliso
WRITE (*,(A),ADVANCE=NO) Anna puolison syntymaika:
READ (*,(A)) mina%puol_synt_aika
WRITE (*,(A),ADVANCE=NO) Anna lasten lukumr:
READ (*,*) mina%lapsia
ALLOCATE (mina%lapset(mina%lapsia))
DO i = 1, mina%lapsia
WRITE (*,*) mina%nimi, : lapsi numero , i
mina%lapset(i)%p => lue()
END DO
END FUNCTION lue
RECURSIVE SUBROUTINE tulosta(mina, polvi)
! Tm aliohjelma tulostaa sisennetyn sukupuun
IMPLICIT NONE
INTEGER, INTENT(IN) :: polvi ! Sukupolven numero
INTEGER :: i
WRITE(*,(5A),advance=no) REPEAT( ,4*polvi), &
TRIM(mina%nimi), (, TRIM(mina%synt_aika) ,)
IF (LEN_TRIM(mina%puoliso) > 0) THEN
WRITE (*,(5A)) & , TRIM(mina%puoliso), (, &
TRIM(mina%puol_synt_aika), )
ELSE
WRITE (*,*)
END IF
CALL tulosta(mina%lapset(i)%p, polvi+1)
END DO
RECURSIVE SUBROUTINE etsi(mina, nimi)
! Tm aliohjelma etsii merkkijonoa nimi sukupuusta
! ja tulostaa lydetyt henkilt
IMPLICIT NONE
CHARACTER(LEN=*), INTENT(IN) :: nimi
INTEGER :: i
IF (INDEX(mina%nimi, nimi) > 0) THEN
WRITE (*,(4A)) TRIM(mina%nimi), &
(, TRIM(mina%synt_aika) ,)
END IF
IF (INDEX(mina%puoliso, nimi) > 0) THEN
WRITE (*,(4A)) TRIM(mina%puoliso), &
263
(, TRIM(mina%puol_synt_aika) ,)
END IF
CALL etsi(mina%lapset(i)%p, nimi)
END DO
END SUBROUTINE etsi
END MODULE sukupuu
Seuraavassa on pohjelma, joka lukee sukupuun sisn ptteelt, tulostaa

sen ja etsii kaikki Juhani-nimiset henkilt sukupuusta.
PROGRAM suku
USE sukupuu
IMPLICIT NONE
TYPE(perhe), POINTER :: juuri
juuri => lue() ! Luetaan sukupuu sisn
CALL tulosta(juuri, 1) ! Tulostetaan sukupuu
WRITE (*,*)
CALL etsi(juuri, Juhani) ! Etsitn kaikki Juhanit
END PROGRAM suku
Ohjelman tulostus hypoteettisella sukupuuaineistolla voisi olla seuraavanlainen:

Matti Virtanen (1.3.1922) & Maija Virtanen (27.8.1924)
Juhani Virtanen (28.3.1945) & Sisko Virtanen (14.4.1943)
Tupu Virtanen (10.10.1970) & Iines Virtanen (4.3.1971)
Hupu Virtanen (30.11.1993)
Aku Virtanen (6.5.1972)
Lupu Virtanen (16.12.1976)
Seija Mkinen (17.7.1946) & Heikki Mkinen (23.8.1942)
Aila Jrvinen (6.9.1950) & Heikki Jrvinen (14.8.1945)
Unelias Jrvinen (6.1.1969) & Lumikki Jrvinen (19.9.1970)
Jr Jrvinen (14.5.1972)
Vilkas Jrvinen (8.6.1975)
Viisas Jrvinen (27.12.1976)
Venla Lahtinen (1.4.1950) & Juhani Lahtinen (30.10.1951)
Eero Lahtinen (5.5.1976)
Elviira Lahtinen (28.7.1981)
Tapani Lahtinen (4.12.1986)
Soile Nieminen (1.3.1958) & Juhani Nieminen (4.7.1960)
Katri Nieminen (19.4.1985)
Mikki Nieminen (13.11.1990)
Minni Nieminen (20.10.1992)
Juhani Virtanen (28.3.1945)
Juhani Lahtinen (30.10.1951)
Juhani Nieminen (4.7.1960)
14.8
Optimointitehtvien ratkaiseminen:
evoluutiostrategiat
Evoluutiostrategiat ovat noin 30 vuotta sitten kehitetty optimointitehtvien ratkaisumenetelm. Dierentiaalievoluutio (DE) on yksinkertainen ver-
264
Fortran 95/2003
sio evoluutiostrategioista. Tm menetelm on osoittautunut kohtalaisen

tehokkaaksi monissa vaikeissa optimointitehtviss.
Koska DE-algoritmi perustuu posin taulukko-operaatioiden kyttn, Fortran mahdollistaa menetelmn toteuttamisen selkesti ja tiiviisti ilman ylimrisi silmukkarakenteita.
14.8.1 Globaali optimointi

Tarkastelemme rajoitteetonta optimointitehtv
minimi f (x), kun x kuuluu joukkoon Rn .
x
Globaalissa optimoinnissa etsitn kohdefunktion f paikallisista minimikohdista arvoltaan pienint, mik on usein erittin vaikeaa. Onneksi usein
riitt likimrisen minimin lytminen.
Dierentiaalievoluutio eli DE soveltuu vaikeiden optimointitehtvien ratkaisumenetelmksi, mutta DE:ss on omat hankaluutensa. Onneksi menetelmss ei kuitenkaan ole yht paljon viriteltvi parametreja kuin esimerkiksi monissa geneettisiss algoritmeissa. DE-menetelm nyttisi mys olevan
melko riippumaton algoritmissa kytetyist parametreista.
14.8.2 Dierentiaalievoluution perusteet

Dierentiaalievoluutiossa ksittelemme ratkaisuvektoreista koostuvaa populaatiota. Populaatiota kytetn satunnaisuuden lhteen muutettaessa
ratkaisuvektoreita parempien ratkaisujen toivossa.
DE-menetelmn populaatioon kuuluu p kpl n-ulotteisia reaalilukuvektoreita xi . Usein populaation kooksi valitaan p = 5n. Jokaisella iteraatiokierroksella jrjestetn p turnausta, joissa verrataan populaation i:nnen jsenen
paremmuutta uuteen ratkaisuvektoriin xt nhden. Tm uusi vektori saadaan yhdistmll vektoriin xi kohinavektori x , joka tuotetaan valitsemalla
satunnaisesti kolme vektoria {xa , xb , xc } vanhasta populaatiosta:
x = xc + c(xa xb ).
Tss kerroin c on menetelmn parametri vlilt (0, 1.2]. Yleens c kannattaa
valita vlilt [0.4, 1.0].
Vektorien xi ja x yhdistminen tapahtuu geneettisist algoritmeista tutulla
rekombinaatiolla (risteytys), jolloin vektorin xt komponentit valitaan risteytymistodennkisyyden r perusteella vektoreista xi ja x . Vakio r on vlill
[0, 1]. Usein r = 0.1 on hyv valinta. Yleens varmistetaan, ett ainakin yksi
vektorin xt komponenteista saadaan kohinavektorista x .
14.8.3 Evoluutiostrategioiden toteutus

Mrittelemme aluksi ohjelmistossa kytetyn laskentatarkkuuden:
265
MODULE de_kind
IMPLICIT NONE
INTEGER, PARAMETER, PUBLIC :: &
prec = SELECTED_REAL_KIND(12,100)
END MODULE de_kind
Varsinainen optimointialgoritmi mritelln moduulissa de_opt:

MODULE de_opt
USE de_kind, ONLY : prec ! Laskentatarkkuus
IMPLICIT NONE
PRIVATE
INTEGER, PARAMETER :: step = 10
PUBLIC :: initialize, optimize, prec
CONTAINS
Moduulin proseduurien mrittelyt . . .
END MODULE de_opt
Moduulissa on siis kolme julkista tunnusta: proseduurit initialize ja

optimize sek vakio prec. Kaikki muu on mritelty yksityiseksi eik ny
moduulin ulkopuolelle.
Populaation alustaminen tehdn seuraavasti:
SUBROUTINE initialize(f, pop, cost, low, up)
IMPLICIT NONE
INTERFACE
FUNCTION f(x) RESULT(res)
USE de_kind, ONLY : prec
REAL(KIND=prec), DIMENSION(:), INTENT(IN) :: x
REAL(KIND=prec) :: res
END FUNCTION f
END INTERFACE
REAL(KIND=prec), DIMENSION(:,:), INTENT(OUT) :: pop
REAL(KIND=prec), DIMENSION(:), INTENT(OUT) :: cost
REAL(KIND=prec), INTENT(IN) :: low, up
INTEGER :: pop_size, i
pop_size = SIZE(pop,2)
IF (SIZE(cost) /= pop_size) &
STOP Kustannusvektori vrn kokoinen!
CALL RANDOM_NUMBER(pop)
pop = low + (up - low)*pop
DO i = 1, pop_size
cost(i) = f(pop(:,i))
END DO
END SUBROUTINE initialize
Aliohjelmaan initialize vlitetn kohdefunktio f, jotta voimme laskea

funktion arvot (cost) alkupopulaatiossa pop. Aliohjelmalle annetaan argumenttina mys ala- ja ylrajat (low ja up) vektorien alkioille.
Varsinainen optimointialiohjelma voidaan mritell seuraavasti:
266
Fortran 95/2003
SUBROUTINE optimize(f, pop, cost, max_iter, c, r)

IMPLICIT NONE
INTERFACE
FUNCTION f(x) RESULT(res)
USE de_kind, ONLY : prec
REAL(KIND=prec) :: res
END FUNCTION f
END INTERFACE
REAL(KIND=prec), DIMENSION(:,:), INTENT(INOUT) :: pop
REAL(KIND=prec), DIMENSION(:), INTENT(INOUT) :: cost
INTEGER, INTENT(IN) :: max_iter
REAL(KIND=prec), INTENT(IN) :: c, r
INTEGER :: n, pop_size, allocstat, iter, i, idx1, idx2, idx3
REAL(KIND=prec), DIMENSION(:,:), ALLOCATABLE :: new_pop
REAL(KIND=prec), DIMENSION(SIZE(pop,1)) :: trial
REAL(KIND=prec) :: score
LOGICAL, DIMENSION(SIZE(pop,1)) :: mask
n = SIZE(pop,1)
pop_size = SIZE(pop,2)
WRITE (*,(A,I2,/,A,I4,/,A,F5.3,/,A,F5.3)) &
Dimensio: , n, &
Pop. koko: , pop_size, &
Kerroin: , c, &
Risteytystodenn: , r
IF (SIZE(cost) /= pop_size) &
STOP Vektori cost vr kokoa!
ALLOCATE(new_pop(n,pop_size), STAT=allocstat)
IF (allocstat /= 0) STOP Virhe muistivarauksessa!
WRITE (*,(A,I4,G14.6)) &
Iteraatio, minimi: , 0, MINVAL(cost)
DO iter = 1, max_iter
DO i = 1, pop_size
CALL triple(i, pop_size, idx1, idx2, idx3)
mask = rnd(n) < r
mask(idx(n)) = .TRUE.
WHERE (mask)
trial = pop(:,idx3) + c*(pop(:,idx1)-pop(:,idx2))
ELSEWHERE
trial = pop(:,i)
END WHERE
score = f(trial)
IF (score < cost(i)) THEN
new_pop(:,i) = trial
cost(i) = score
ELSE
new_pop(:,i) = pop(:,i)
END IF
END DO
pop = new_pop
267
IF (MOD(iter,step) == 0) THEN
WRITE (*,(A,I4,G14.6)) Iteraatio, minimi: , &
iter, MINVAL(cost)
END IF
END DO
END SUBROUTINE optimize
Aliohjelmassa kytetn hyvksi aliohjelmaa triple sek funktioita rnd

ja idx. Varsinainen laskenta tehtn sisimmss DO-silmukassa. Aliohjelma
triple palauttaa kolmen eri alkion jrjestysnumerot. Lauseissa
mask = rnd(n) < r
mask(idx(n)) = .TRUE.
lasketaan rekombinaatiota ohjaava looginen vektori mask, jota kytetn

WHERE-rakenteessa. Funktio rnd palauttaa n alkion mittaisen satunnaislukuvektorin, ja funktio idx palauttaa kokonaisluvun vlilt 1, 2, . . . , n. Mikli uusi vektori trial on parempi ratkaisu kuin populaation i:nnes alkio
pop(:,i), valitaan se uuteen populaatioon.
Vektorikolmikon {xa , xb , xc } indeksit voidaan laskea seuraavasti:
SUBROUTINE triple(i, n, i1, i2, i3)
IMPLICIT NONE
INTEGER, INTENT(IN) :: i, n
INTEGER, INTENT(OUT) :: i1, i2, i3
DO
i1 = idx(n)
IF (i1 /= i) EXIT
END DO
DO
i2 = idx(n)
IF (i2 /= i .AND. i2 /= i1) EXIT
END DO
DO
i3 = idx(n)
IF (ALL(i3 /= (/i,i1,i2/))) EXIT
END DO
END SUBROUTINE triple
Funktio rnd palauttaa satunnaisvektorin, jossa on n alkiota vlilt [0, 1):

FUNCTION rnd(n)
IMPLICIT NONE
REAL(KIND=prec), DIMENSION(n) :: rnd
CALL RANDOM_NUMBER(rnd)
END FUNCTION rnd
Funktio idx palauttaa satunnaisen kokonaisluvun vlilt 1, 2, . . . , n:

INTEGER FUNCTION idx(n)
IMPLICIT NONE
REAL(KIND=prec) :: x
idx = n*x + 1
END FUNCTION idx
268
Fortran 95/2003
14.8.4 DE:n kyttesimerkki

Olkoon minimoitavana funktio

f (x) = 1 + (xi 100)2 /4000
cos(xi 100)/ i.
i
Tmn funktion globaali minimi on x = (100, 100, . . . , 100) ja minimiarvo

f (x ) = 0. Voimme mritell kohdefunktion f seuraavasti:
MODULE fun
USE de_opt, ONLY : prec
CONTAINS
REAL(KIND=prec) FUNCTION f(x)
IMPLICIT NONE
REAL(KIND=prec), PARAMETER :: d = 4000.0
INTEGER :: i, n
REAL(KIND=prec), DIMENSION(SIZE(x)) :: ival
n = SIZE(x)
ival = (/ (i, i = 1, n) /)
f = SUM((x - 100.0)**2)/d
f = f - PRODUCT(COS((x - 100.0)/SQRT(ival))) + 1.0
END FUNCTION f
END MODULE fun
Seuraavassa pohjelmassa kytmme moduulia de_opt moduulista fun

lytyvn kohdefunktion f minimointiin:
PROGRAM de_test
USE fun, ONLY : f ! Kohdefunktio
USE de_opt, ONLY : initialize, optimize, prec
IMPLICIT NONE
INTEGER, PARAMETER :: n = 5, p = 24, max_iter = 500
REAL(KIND=prec) :: low = -600, up = 600, &
r = 0.1, c = 0.7
REAL(KIND=prec), DIMENSION(n,p) :: popul
REAL(KIND=prec), DIMENSION(p) :: values
CALL initialize(f, popul, values, low, up)
WRITE (*,(A,/,(3G14.6))) Arvot alussa: , values
CALL optimize(f, popul, values, max_iter, c, r)
WRITE (*,(A,/,(3G14.6))) Arvot lopussa: , values
WRITE (*,(A,/,G14.6)) Minimiarvo: , MINVAL(values)
WRITE (*,(A,/,(3G14.6))) Minimikohta: , &
popul(:,MINLOC(values))
END PROGRAM de_test
Tehtvn dimensioksi asetettiin n = 5. Ohjelmassa valitiiin populaation

kooksi p = 24, iteraatioiden mrksi 500, risteytystodennkisyydeksi
r = 0.1 ja kertoimeksi c = 0.7. Alkupopulaation alkioiden komponentit
xi ovat vlilt [600, 600].
Jos edell esitellyt moduulit ja pohjelma ovat nimin vastaavissa tiedostoissa (de_kind.f90, de_opt.f90 jne.), voidaan ohjelma knt, linkitt
269
ja ajaa seuraavasti:
%
%
%
%
%
f90 -c de_kind.f90
f90 -c de_opt.f90
f90 -c fun.f90
f90 de_test.f90 de_kind.o de_opt.o fun.o
./a.out
Seuraavassa on esimerkki ohjelman tulostuksesta:

Arvot alussa:
308.759
124.886
176.973
...
162.530
150.726
151.268
Dimensio: 5
Pop. koko:
24
Kerroin: 0.700
Risteytystodenn: 0.100
Iteraatio, minimi:
0
22.6019
Iteraatio, minimi:
10
5.10033
Iteraatio, minimi:
20
2.17014
Iteraatio, minimi:
30
1.47248
...
Iteraatio, minimi: 470 0.187714E-04
Arvot lopussa:
0.685460E-04 0.148735E-01 0.525957E-04
...
0.149787E-01 0.148037E-01 0.617226E-05
Minimiarvo:
0.617226E-05
Minimikohta:
99.9968
99.9993
100.002
100.000
99.9983
Ohjelma siis lysi arvion tehtvn globaalille minimikohdalle.
14.8.5 Listietoa
DE-menetelm on esitelty lehdess Dr. Dobbs Journal (April 1997, sivut 1824). Optimointimenetelmi on esitelty CSC:n oppaissa Optimointitehtvien
ratkaiseminen [Haa04] ja Numeeriset menetelmt kytnnss [HHL+ 02].
14.9
Lineaaristen yhtlryhmien ratkaisu
Liittogradienttimenetelm (conjugate gradient method) on usein tehokas tapa ratkaista lineaarisia yhtlryhmi
Ax = b.
270
Fortran 95/2003
Tss vektorit x ja b kuuluvat joukkoon Rn ja matriisi A on symmetrinen

ja positiivisesti deniitti [HHL+ 02]. Oletamme mys, ett matriisi A on tihe
(vhn nollasta poikkeavia alkioita)
Seuraavassa on kuvaus yksinkertaisesta liittogradienttimenetelmst:
r1 = b Ax1
p1 = r 1
k=1
rk , rk
DO WHILE 1 1 >
r , r
k
rk , rk
pk , Apk
xk+1 = xk + k pk
rk+1 = rk k Apk
k
rk+1 , rk+1
rk , rk
pk+1 = rk+1 + k pk
k
END DO
= k+1
Algoritmin lopetusehdossa vaaditaan, ett residuaalin rk = b Axk normi

rk , rk on pienentynyt tarpeeksi.
Mrittelemme laskentatarkkuuden moduulissa cg_precision:
MODULE cg_precision
IMPLICIT NONE
! Liukulukujen tarkkuus:
END MODULE cg_precision
Toteutamme liittogradienttialgoritmin seuraavasti:

MODULE cg_alg
USE cg_precision, ONLY : prec
CONTAINS
SUBROUTINE cg(n, b, x, itmax, eps, matr_mult)
! Aliohjelma ratkaisee lineaarisen yhtlryhmn Ax=b
! liittogradienttialgoritmilla (CG)
IMPLICIT NONE
! Yhtlryhmn koko
REAL(prec), INTENT(IN) :: b(n)
! Oikean puolen vektori
REAL(prec), INTENT(INOUT) :: x(n) ! Alkuarvaus ja ratkaisu
INTEGER, INTENT(IN) :: itmax
! Iteraatioiden lkm
REAL(prec), INTENT(IN) :: eps
! Suppenemiskriteeri
EXTERNAL matr_mult
! Laskee matriisi-vektoritulon
REAL(prec) :: p(n)
! Etsintsuunta
REAL(prec) :: ap(n)
! A*p
REAL(prec) :: res(n)
! Residuaali
REAL(prec) :: alpha, beta ! Askelpituudet
271
REAL(prec) :: rnorm
! Residuaalin normin neli
REAL(prec) :: rnnorm
! Uuden residuaalin normin neli
REAL(prec) :: rnorm0
! Alkuresiduaalin normin neli
INTEGER :: k
! Iteraatiokierros
CALL matr_mult(n, x,res) ! Laske alkuresiduaali b-Ax
res = b - res
p = res
! Etsintsuunta on alkuresiduaali
k = 1
rnorm = DOT_PRODUCT(res,res)
rnorm0 = rnorm
! Alkuresiduaalin normin neli
DO WHILE(k < itmax .AND. SQRT(rnorm)/SQRT(rnorm0) > eps)
CALL matr_mult(n, p, ap)
alpha = rnorm / DOT_PRODUCT(p,ap)
x = x + alpha * p
! Pivit iteraattia
res = res - alpha * ap ! Pivit residuaalia
rnnorm = DOT_PRODUCT(res,res)
beta = rnnorm / rnorm
p = res + beta * p
! Pivit etsintsuuntaa
rnorm = rnnorm
WRITE(*,*) k, SQRT(rnorm)
k = k + 1
END DO
WRITE (*, (/,A,I3,A,/)) CG suppeni , &
k-1, iteraatiossa
END SUBROUTINE cg
END MODULE cg_alg
Liittogradienttialgoritmissa tarvitaan matriisi-vektoritulon laskeva aliohjelma. Vlitmme aliohjelmaan cg tmn aliohjelman muodollisessa argumentissa matr_mult.
Seuraavassa moduulissa mrittelemme matriisitulon laskevan aliohjelman
cg_matrix_mult. Moduulissa on lisksi aliohjelma cg_matrix_init matriisin alustamiseen. Matriisi talletetaan moduulin yksityiseen muuttujaan
coeffmat.
MODULE cg_matrix
IMPLICIT NONE
REAL(prec), DIMENSION(:,:), ALLOCATABLE, PRIVATE :: &
coeffmat
CONTAINS
SUBROUTINE cg_matrix_init(n)
! Aliohjelma alustaa kerroinmatriisin
INTEGER :: allocstat, i, j
ALLOCATE(coeffmat(n, n), STAT=allocstat)
IF (allocstat /= 0) STOP muistinvaraus eponistui!
DO j=1, n
DO i=1, n
coeffmat(i,j) = 1/(1.0_prec+ABS(i-j))
END DO
END DO
END SUBROUTINE cg_matrix_init
272
Fortran 95/2003
SUBROUTINE cg_matrix_mult(n, x, y)
! Aliohjelma laskee matriisi-vektoritulon y=A*x
REAL(prec), INTENT(IN) :: x(n)
REAL(prec), INTENT(OUT) :: y(n)
y = MATMUL(coeffmat, x)
END SUBROUTINE cg_matrix_mult
END MODULE cg_matrix
Olemme sijoittaneet matriisitulon laskevan aliohjelman erilliseen moduuliin, jolloin ohjelman muuttaminen myhemmin on helpompaa. Tarvittaessa voisimme muuttaa tt moduulia vaikkapa tallettaen matriisin nauhamatriisina tai harvana matriisina. Mys rinnakkaistetun version tekeminen on
helpompaa [HM01].
Moduulien cg_alg ja cg_matrix avulla voimmekin nyt toteuttaa liittogradienttimenetelmn. Tarvittava pohjelma on esitetty seuraavassa:
PROGRAM cg_iterate
! Ohjelma ratkaisee tihen lineaarisen yhtlryhmn Ax=b
! liittogradienttialgoritmilla
USE cg_matrix, ONLY : cg_matrix_init, cg_matrix_mult
USE cg_alg, ONLY : cg
IMPLICIT NONE
INTEGER :: n
REAL(prec), DIMENSION(:), ALLOCATABLE :: rhs, x
INTEGER :: allocstat, u, t1, t2
WRITE (*,(A), ADVANCE=no) Anna matriisin koko n:
READ (*,*) n
CALL SYSTEM_CLOCK(count_rate=u)
CALL SYSTEM_CLOCK(count=t1)
ALLOCATE (rhs(n), x(n), STAT=allocstat)
IF (allocstat /= 0) STOP Muistinvaraus eponistui!
CALL cg_matrix_init(n)
rhs = 1
x = 0
CALL cg(n, rhs, x, 100, 1e-5_prec, cg_matrix_mult)
CALL SYSTEM_CLOCK(count=t2)
WRITE (*,(A,I4,A,F6.2)) Koko: , n, &
Aika: , REAL(t2-t1)/u
END PROGRAM cg_iterate
Voimme knt ja linkitt ohjelmamme seuraavasti:

% f90 -c cg_precision.f90
% f90 -c cg_alg.f90 cg_matrix.f90
% f90 cg_iterate.f90 cg_precision.o cg_alg.o cg_matrix.o

% ./a.out
273
Anna matriisin koko n: 500

1
1.62835857655826
2 0.495156832021520
3 0.236759072338562
...
15 2.818037136816830E-004
16 1.529607014624823E-004
CG suppeni
Koko:
16 iteraatiossa
500 Aika:
0.23
Siis 500 500 -kokoisen yhtlryhmn ratkaisuun kului aikaa noin 0.2 sekuntia.
14.9.1 Listietoja
Lineaaristen yhtlryhmien ratkaisusta kerrotaan CSC:n oppaassa Numeeriset menetelmt kytnnss [HHL+ 02]. Rinnakkaistettu versio liittogradienttialgoritmista lytyy CSC:n julkaisemasta MPI-oppaasta [HM01].
Harjoitustehtvi
1. Muuta kappaleen 14.1 (sivu 234) pinomoduulia siten, ettei pinolla ole
kiinte maksimikokoa.
2. Lis nelilaskimeen potenssiinkorotusoperaatio ^. Voit kytt komentona mys Fortranin potenssiinkorotusoperaattoria **, mutta tllin
joudut ksittelemn mys kahdesta merkist koostuvia komentoja.
3. Jos lajiteltavana on suuri mr dataa, kannattaa kytt esimerkiksi
Quicksort-algoritmia (katso vaikkapa teoksia [CLR90, Sed84]). Toteuta
kappaleen 14.2.1 lajittelumoduuli kytten Quicksortia.
4. Muuta kappaleen 14.3 sokkelonteko-ohjelman tulostusproseduuria siten, ett tulostuksessa ei kytet taulukko-operaatioita vaan sokkelo
tulostetaan suoraan kytten WRITE-lausetta.
5. Muuta sokkelonteko-ohjelman tulostusproseduuria siten, ett se tulostaa mys sokkelon ratkaisun. Vihje: aloita polun loppupst.
6. Kirjoita ohjelma, joka ratkaisee valmiin sokkelon. Sokkelon voi sytt
ohjelmalle esimerkiksi merkkijonotaulukkona.
7. Tutki kappaleessa 14.4 esiteltyj yksiulotteisia soluautomaatteja. Miten
kyttytyy totalistinen soluautomaatti (k = 2, r = 1), sntnumero
10? Ent (k = 5, r = 1)-soluautomaatti, snt 80092580? (Voit tulostaa
soluautomaatin vreiss kyttmll esim. PPM-tiedostomuotoa.)
274
Fortran 95/2003
8. Muuta Life-soluautomaattia simuloivaa ohjelmaa siten, ett saat talteen

erillisiin tiedostoihin soluautomaatin sukupolvia esittvt tilanteet. Voit
nimet tiedostot nimill tila.001, tila.002 jne.
9. Muuta binripuun toteuttavaa ohjelmaa siten, ett ohjelmaan voi sytt puhelinnumeroita ja niihin liittyvi nimi. Tee hakuja puhelinnumeroiden perusteella.
10. Syt sukupuun toteuttavalle ohjelmalle oma sukupuusi ja tee siit hakuja.
11. Hae maksimi funktiolle
f (x) = 3 (1 x1 )2 exp(x12 (x2 + 1)2 ) 10 (
exp(x12 x22 )
x1
x13 x25 )
5
1
exp((x1 + 1)2 x22 ) + 10.
3
Muuta tehtv minimointitehtvksi ja kyt kappaleessa 14.8 esitelty DE-menetelm. Funktiolla on kolme lokaalia maksimia lytk
menetelm aina globaalin maksimin?
12. Tutki kappaleessa 14.9 esitellyn liittogradienttimenetelmn suppenemisnopeutta. Miten menetelmn tehokkuus riippuu alkuarvauksen hyvyydest?
13. Pohjustus (preconditioning) nopeuttaa liittogradienttimenetelmn suppenemista. Toteuta kappaleen 14.9 liittogradialgoritmiin jokin sopiva
pohjustusmenetelm [HHL+ 02].
15. Siirtyminen Fortran 95 -kieleen
15
275
Siirtyminen Fortran 95
-kieleen
Tm luku on tarkoitettu niille, jotka ovat siirtymss FORTRAN 77:st

Fortran 95:een. Luvusta lienee hyty mys niille, jotka joutuvat perehtymn vanhoihin FORTRAN-ohjelmiin. Kerromme, mit uutta Fortran 95
-standardissa on verrattuna FORTRAN 77:n. Lisksi kerromme Fortran 95:n
vltettvist ja harvoin tarvittavista piirteist. Nm piirteet ovat jnteit
vanhasta FORTRANista, ja ksittelemme niiden korvaamista paremmilla ilmaisukeinoilla.
15.1
Miten Fortran 95:een kannattaa siirty
Trkein ohje uuden standardin kyttn ottamiseksi on:

If it works, dont x it!
Siis jos kytsssi on hyvin toimiva FORTRAN 77 -koodi, ei sit yleens
kannata muuntaa Fortran 95:ksi. Luultavasti muunnetusta koodista tulisi
kuitenkin vanhan FORTRANin nkist.
Fortran 95 -kntji voi kuitenkin kytt FORTRAN 77 -koodien kntmiseen. Fortran 95 -kntjt tarjoavat hyvn diagnostiikan esimerkiksi epstandardien ja vanhentuvien piirteiden lytmiseksi.
Jos olet tekemss kokonaan uutta koodia, kannattaa se kirjoittaa Fortran 95:ll jo standardiin kuuluvan paremman virheentarkistuksen takia. Jos
voit kytt vanhaa koodia aliohjelmakirjaston tapaan, eik uusi koodi edellyt vanhan koodin uudelleen kirjoittamista, voi Fortran 95:n kytt harkita
vanhan ohjelmakoodin rinnalla.
Jos vanhaa FORTRAN-koodia on muutettava huomattavasti (uusien ominaisuuksien lisys jne.), voit samalla koodata ohjelmakoodin uudestaan Fortran 95:ksi. Jos ohjelmassa on paljon vektori- ja taulukko-operaatioita, voi
koodi samalla huomattavasti selkeyty. Mys Fortran 95:een kuuluvia rakenteisia tietotyyppej kannattaa kytt koodin yksinkertaistamiseen.
276
15.2
Fortran 95/2003
Fortran 95:n uudet piirteet
Kymme aluksi lpi Fortran 95:n suurimmat muutokset aikaisempaan FORTRAN 77 -standardiin verrattuna.
Lhdekoodin vapaa syttmuoto tarjoaa luontevan tavan kirjoittaa ohjelmakoodia. Samalla vltyt turhilta sarakesidonnaisuuteen liittyvilt virheilt.
Fortran 95 tarjoaa moduulien ja sisisten proseduurien kyttmahdollisuuden, jolloin proseduurien argumentit voidaan tarkistaa knnsaikana. Lisksi voit kirjoittaa rekursiivisia proseduureja.
Fortran 95:n lajiparametrit mahdollistavat muuttujien lukualueen ja tarkkuuden mrittelyn laitteistosta riippumattomalla tavalla. Tllin koodin
siirrettvyys paranee.
Fortran 95:ss on mahdollisuus mritell omia muuttujatyyppej ja yleist
standardiproseduurit ja -operaattorit kohdistumaan uuden tyyppisiin muuttujiin. Lisksi voit mritell omia operaattoreita. Geneeristen proseduurien
avulla voit ksitell saman nkisell proseduurin kutsulla eri tyyppisi argumentteja.
Taulukkosyntaksi ja osoitinmuuttujat mahdollistavat tehokkaamman ja joustavamman tavan ksitell suuria tietomri. Dynaamisen muistinksittelyn
ansiosta proseduureille ei en tarvitse vlitt argumentteina tytiloja.
SELECT CASE -ohjausrakenne sek DO-toistorakenteen yleisemmt muodot
helpottavat ohjelmakoodin logiikan ilmaisemista.
Sytt- ja tulostusproseduurien ominaisuuksia on laajennettu. Esimerkiksi
tiedonsiirto NAMELIST-ryhmien avulla kuuluu nyt standardiin.
Fortran 95 sislt paljon uusia standardifunktioita ja -aliohjelmia (yhteens
standardiproseduureja on 115). Useimmat nist standardiproseduureista
ovat geneerisi eli niit voi kytt ksittelemn eri tyyppisi argumentteja.
Tmn lisksi Fortran 95 -kntj tarjoaa aikaisempaa tarkemmat ilmoitukset virheelliselle tai epstandardille lhdekoodille. Kntjn on mm. ilmoitettava vanhentuvien Fortranin piirteiden kytst.
15.3
FORTRAN 77:n huonoja puolia
Monet nykyiset ohjelmointikielet tarjoavat FORTRAN 77: kehittyneemmn

ja helpomman tavan ohjelmoida. Seuraavassa kymme lpi trkeimpi vanhan standardin puutteita. Niden lisksi FORTRAN 77:st puuttuivat mys
rekursiiviset proseduurit sek mahdollisuus rinnakkaisuuden esittmiseen.
277
15.3.1 Vanha sarakesidonnainen syttmuoto

FORTRAN 77:ss kytetty sarakesidonnainen lhdekoodin syttmuoto on
syyt korvata Fortran 95:n vapaalla syttmuodolla. Sarakesidonnaista muotoa voi viel kytt, mutta tm on virhealtista ja tarpeettoman hankalaa vapaamuotoiseen syttmuotoon verrattuna. Sarakesidonnainen syttmuoto
on muinaisjnne reikkorttien aikakaudelta, jolloin se oli jrkev tapa kirjoittaa ohjelmakoodia.
Samassa ohjelmatiedostossa ei voi kytt sek sarakesidonnaista ett vapaamuotoista syttmuotoa. Jos vanhaa ohjelmaa muutetaan vapaamuotoiseen syttmuotoon, muutos tytyy tehd ohjelmatiedosto kerrallaan. Huomaa, ett INCLUDE-lauseella ohjelmayksikn sisn luettu ohjelmakoodi tulkitaan osaksi samaa ohjelmatiedostoa.
Sarakesidonnaisessa muodossa rivin pituus on korkeintaan 72 merkki, mik aiheuttaa helposti ongelmia ja ohjelmointivirheit. Ensimmiset viisi saraketta on varattu lausenumeroille. Kuudennessa sarakkeessa voi olla vain
jatkorivin tunnus (vlilynnist tai nollasta poikkeava merkki).
Fortran 95:n sarakesidonnaisen syttmuodon kommenttirivi alkaa sarakkeessa 1 olevalla vlilynnist tai nollasta poikkeavalla merkill.
FORTRAN 77:ss kommenttirivi voi alkaa vain merkill C tai *. Kommentteja
ei voi sijoittaa koodirivien loppuun sarakesidonnaisessa lhdekoodissa.
Ohjelmakoodissa saa merkkijonojen ja kommenttien ulkopuolella kytt
vain isoja kirjaimia. Muuttujien nimet voivat olla korkeintaan kuuden merkin
mittaisia, eik alaviiva (_) kuulu merkistn.
15.3.2 Vlilynnit eivt olleet merkitsevi

FORTRAN 77 -standardissa eivt vlilynnit olleet merkitsevi muualla kuin
merkkijonovakioiden sisll. Tten jos rivi
DO 15 I = 1,10
muuttuu kirjoitusvirheen takia riviksi

DO 15 I = 1.10
niin lauseen merkitys muuttuu DO-silmukan aloituksesta sijoituslauseeksi

DO15I=1.10
Urbaani legenda kertoo, ett ers avaruusluotain menetettiin tllaisen Fortran-koodissa olleen kirjoitusvirheen vuoksi.
Onneksi nykyisess Fortran-standardissa vlilynnit ovat merkitsevi. Lisksi lause IMPLICIT NONE suojaa mahdollisilta muuttujien nimien kirjoitusvirheilt. Seuraavassa esimerkki:
INTEGER ARV0, ARV1
ARVO = 12
ARV1 = FUN(ARVO)
278
Fortran 95/2003
Huomasitko, ett koodissa oli kirjoitusvirhe? Muuttujan nimen piti olla ARV0
eik ARVO (tai pienill kirjaimilla: arv0 eik arvo). Jos tss tapauksessa olisi
kytss Fortranin tunnusten etumerkkisnt, vlitettisiin funktioon FUN
kokonaislukumuuttujan arv0 sijaan alustamaton reaalilukumuuttuja arvo.
Tuloksena on arvaamattomasti kyttytyv ohjelma.
15.3.3 Numeeristen tyyppien huono siirrettvyys

FORTRAN 77 sislt reaalilukutyypit REAL ja DOUBLE PRECISION, jotka
merkitsevt eri koneilla eri asioita. Tten toisen koneen kaksoistarkkuus
voi vastata toisen koneen yksinkertaista tarkkuutta. Tarkkuuden muunnoksia varten on FORTRAN 77 -kntjiss lukuisia muunnosvalitsimia, joilla saa esimerkiksi REAL-tyypin muuttujat vastaamaan DOUBLE PRECISION
-tyyppi. Tm on kuitenkin virhealtista, erityisesti jos ohjelmakoodissa on
kytetty COMMON-alueita tai EQUIVALENCE-lauseita.
Fortran 95:n lajiparametrit korvaavat kokonaan DOUBLE PRECISION -tyypin
kytttarpeen. Lisksi lajiparametrit mahdollistavat kytetyn koneen numeeristen ominaisuuksien selvittmisen. Kytettviss on mm. standardifunktiot EPSILON ja PRECISION, joita voi kytt vaikkapa algoritmin suppenemiskriteerin laskemiseen.
15.3.4 Dynaamisten ja rakenteisten tietotyyppien puute

FORTRAN 77 tarjosi vain staattisen tilanvarauksen taulukoille. Tten tilapist tytilaa ei voinut luoda tarpeen mukaan, vaan ohjelman kynnistyess oli varattava tytilavektoreita mahdollista myhemp tarvetta varten.
FORTRAN 77 ei myskn tuntenut rakenteisia tietotyyppej tai osoitinmuuttujia. Tten useimmat tietorakenteet oli toteutettava hankalasti skalaarien ja taulukkojen avulla. Algoritmeissa tehtiin usein tarpeetonta datan
kopiointia paikasta toiseen, mink olisi voinut vltt osoitinmuuttujilla.
Fortran 95:ss on kytettviss dynaamiset taulukot (mreet ALLOCATABLE
ja POINTER) sek proseduurien automaattisesti varattavat taulukot.
15.3.5 Vaaralliset riippuvuudet tiedon talletustavasta

FORTRAN 77:ss olivat COMMON-alueet ainoa tapa jakaa globaalia dataa ohjelmayksikkjen kesken, jos ei halunnut vlitt dataa proseduurien parametrilistoissa. COMMON-alueiden kytt koskevat snnt olivat hyvin vljt,
jolloin kyttj pystyi tekemn pahoja ohjelmointivirheit.
Lisksi EQUIVALENCE-lausetta kytettiin mm. taulukkojen aliasten luomiseen, mik teki koodeista usein hyvin koneriippuvaisia. Tm aiheutti suuria
ongelmia koodien siirtmiselle koneesta toiseen.
Ikv kyll FORTRAN 77 -kieless ei ollut vaihtoehtoja COMMON-alueiden
ja EQUIVALENCE-lauseiden kytlle. Fortran 95:ss voi kytt moduuleja
279
COMMON-alueiden sijasta. EQUIVALENCE-lauseet voi korvata osoitinmuuttujilla tai vaikkapa standardifunktiolla TRANSFER.
Seuraava FORTRAN 77 -koodi saattaa knty ilman varoituksia:
PROGRAM HUH
REAL LUKU, A, B
COMMON /HUPS/ LUKU, A, B
CALL NURJA
WRITE (*,*) LUKU,A,B: , LUKU, A, B
END
SUBROUTINE NURJA
COMMON /HUPS/ LUKU, A, B
LUKU = 3
A = 4
B = 5
END
Ohjelma toimii odottamattomalla tavalla:

LUKU,A,B:
0.0000000E+00
4.000000
5.000000
Vaikka muuttujalle LUKU annettiin arvoksi luku 3, tulosti ohjelma arvon nolla. Tm johtuu siit, ett aliohjelmassa NURJA kytettiin alkukirjainsnt,
ja muuttuja LUKU oletettiin kokonaislukutyyppiseksi! Tllin pohjelmassa
kytettyyn COMMON-alueeseen tallettui tmn kokonaislukumuuttujan arvo.
15.4
FORTRAN 77 -koodien muuntaminen uuteen

muotoon
Seuraavasta muistilistasta on hyty muunnettaessa vanhoja FORTRAN 77

-koodeja uuden Fortran 95 -kielen mukaisiksi.
Jos ohjelmointiprojekti on iso ja siin on mukana monta ohjelmoijaa, on
syyt kytt versionhallintajrjestelm. Tllin pystytn tarvittaessa palaamaan takaisin aikaisempiin ohjelmistoversioihin.
Muodosta testiaineisto koodin oikeellisuuden testaamiseksi, jolloin havaitset virheet varmemmin kuin jlkikteen testaamalla. Testaa ohjelmayksikkj sek erikseen ett yhdess toisten ohjelmayksikkjen kanssa.
l kyt sarakesidonnaista ohjelmakoodin syttmuotoa, sill se huonontaa ohjelmakoodin luettavuutta. Muuta kommenttimerkki C huutomerkiksi
! sek muuta jatkorivit uuden kytnnn mukaisiksi.
Seuraavassa on pieni esimerkki FORTRAN 77 -koodista:
SUBROUTINE ACTSCA
C
C
C
ACTSCA
ACTIVATES THE RESCALING
DOUBLE PRECISION DIST,BIAS,GRAGRA,GRA

COMMON /SCALE/ DIST(10,10,20),BIAS(10,20),
280
Fortran 95/2003
GRA(10,20),NGRA(20),LSCA
C
IF(LSCA.EQ.0)LSCA = 1
C
RETURN
END
Tmn voisi muuntaa aluksi seuraavaan muotoon:

SUBROUTINE ACTSCA
!
ACTSCA
ACTIVATES THE RESCALING
DOUBLE PRECISION DIST,BIAS,GRAGRA,GRA

COMMON /SCALE/ DIST(10,10,20),BIAS(10,20), &
GRA(10,20),NGRA(20),LSCA
IF(LSCA.EQ.0)LSCA = 1
RETURN
END
Tss muutimme kommenttimerkiksi huutomerkin !. Lisksi kytimme Fortran 95:n tapaa ilmaista jatkorivi merkill &. Koodi on nyt vapaan lhdekoodin
muotoista.
Seuraava versio voisi nytt tlt:
SUBROUTINE actsca
! actsca activates the rescaling
USE scale_mod, ONLY : lsca
IMPLICIT NONE
IF (lsca == 0) lsca = 1
END SUBROUTINE actsca
Tss siirsimme COMMON-alueen SCALE tiedot moduuliin scale_mod. Aliohjelmassa otimme tst moduulista kyttn vain tunnuksen lsca. Aliohjelma yksinkertaistui huomattavasti.
l kyt Fortranin implisiittist tyypinmrittely eli alkukirjainsnt.
Kyt sen sijaan lausetta IMPLICIT NONE ohjelmayksikkjen alussa. Tllin
mahdolliset tunnusten kirjoitusvirheet tulevat useimmiten esiin jo knnsaikana.
Selkeyt ja yhtenist muuttujamrittelyt. l kyt erillisi DIMENSION- ja
PARAMETER-lauseita, vaan vastaavia tyyppimreit. Siis mrittelyt
INTEGER N
PARAMETER (N = 100)
REAL X
DIMENSION X(N)
on syyt muuttaa muotoon

Tarkista, ettei koodissa kytet epstandardeja piirteit, kuten tyyppi DOUBLE
281
COMPLEX, tyyliin REAL*16 mriteltyj muuttujien tarkkuuksia ja NAMELISTdatan epstandardeja versioita.

Poista vanhentuviin piirteisiin kuuluvat ohjausrakenteet. Kyt esimerkiksi
DO ... END DO -rakenteita seuraavan tyyppisten rakenteiden sijaan:
100
DO 100 I = 1, N
PRINT (F10.6), X(I)
Korvaava ja parempi rakenne olisi seuraava:

DO i = 1, n
PRINT (F10.6), x(i)
END DO
Monet silmukat voi mys korvata taulukkosyntaksilla. Edellisen silmukan

voi kirjoittaa seuraavasti yhdeksi lauseeksi:
PRINT (F10.6), x(1:n)
Kyt moduuleita, sisisi aliohjelmia ja INTERFACE-lohkoja proseduurikutsujen virheentarkistukseen.

Korvaa COMMON-alueet ja BLOCK DATA -yksikt moduuleilla. Tllin ohjelman
siirrettvyys paranee ja saat kyttsi Fortran 95:n kehittyneet tyyppitarkistukset.
Vlt EQUIVALENCE-lauseita, sill nm heikentvt ohjelmakoodin siirrettvyytt. EQUIVALENCE-lauseiden tarve on poistunut uuden standardin myt. Kytettviss on korvaavina vaihtoehtoina mm. taulukkojen POINTER-,
TARGET- ja ALLOCATABLE-mreet sek TRANSFER- ja RESHAPE-funktiot.
Kyt dynaamisia taulukkomrittelyj kiinteiden tytilavektoreiden sijaan.
Voit kytt joko taulukoiden ALLOCATABLE-mrett tai osoitinmuuttujia
(POINTER). Dynaamista muistinksittely on esitelty luvussa 11 (sivu 164).
Korvaa lausefunktiot (statement function) sisisill proseduureilla. Nm
tarjoavat paremmat knnsaikaiset tarkistukset ja tuottavat tehokasta koodia. Ulkoisten proseduurien sijaan tulisi kytt joko sisisi proseduureja
tai moduuleja.
Muuta mrittely DOUBLE PRECISION esimerkiksi mrittelyksi
INTEGER, PARAMETER :: tarkka = SELECTED_REAL_KIND(10)
REAL(KIND=tarkka) :: x
Muuttujalla x on tss tapauksessa vhintn 10 desimaalinumeron esitystarkkuus.
15.5
Ohjausrakenteiden kytt
FORTRAN 77:ss ei ollut kytettviss END DO -lausetta silmukan lopettamiseen, mik johti seuraavan kaltaisiin vaikeasti luettaviin silmukoihin:
DOUBLE PRECISION A, X
282
Fortran 95/2003
DIMENSION A(N,N), X(N)
100
DO 100 I=2,N
X(I)=1D30
DO 100 II=1,N
A(II,I)=0D0
Tmn toistorakenteen voi esitt selkemmin seuraavasti:

INTEGER, PARAMETER :: tarkka = SELECTED_REAL_KIND(12)
REAL(KIND=tarkka), DIMENSION(n,n) :: a
REAL(KIND=tarkka), DIMENSION(n) :: x
DO i = 2, n
x(i) = HUGE(x)
DO ii = 1, n
a(ii,i) = 0.0_tarkka
END DO
END DO
Ohjelmakoodissa kytettiin standardifunktiota HUGE suurimman muuttujatyypill x esitettvn luvun tuottamiseen.

Edelliset silmukat saadaan viel selkempn muotoon taulukkosyntaksia
kyttmll:
x(2:n) = HUGE(x)
a(1:n,2:n) = 0.0_tarkka
Monissa vanhoissa Fortran-koodeissa on esimerkiksi seuraavan nkisi rakenteita:

INTEGER I, M, A, B
100
200
500
IF (I .EQ. 1) GOTO 100

IF (I .EQ. 3) GOTO 200
M = M + A
GOTO 500
M = M + B
GOTO 500
M = M - B
CONTINUE
Tmn esimerkin voi kirjoittaa selkemmin SELECT CASE -rakennetta kytten seuraavasti:
SELECT CASE (i)
CASE (1)
m = m + b
CASE (3)
m = m - b
CASE DEFAULT
m = m + a
END SELECT
Ehk selkein mahdollisuus on IF-rakenteen kytt:
283
IF (i == 1) THEN
m = m + b
ELSE IF (i == 3) THEN
m = m - b
ELSE
m = m + a
END IF
Haarautuva hyppylause (computed goto) johtaa helposti erittin sekavaan

ohjelmalogiikkaan. Seuraavassa on esimerkki:
INTEGER EHTO
REAL X, Y, Z
10
11
GO TO (10, 11, 10) EHTO

Y = Z
X = Y + 2
X = X**2
X = X + 3
Edellinen rakenne voitaisiin esitt yksinkertaisemmin seuraavasti:

INTEGER :: ehto
REAL :: x, y, z
SELECT CASE (ehto)
CASE (1,3)
x = y + 2
x = x**2
x = x + 3
CASE (2)
x = x + 3
CASE DEFAULT
y = z
x = y + 2
x = x**2
x = x + 3
END SELECT
Tss tapauksessa voisi kytt mys IF-rakennetta (tm on harjoitustehtvn).
15.6
COMMON-alueiden korvaus moduuleilla
Seuraavassa on esimerkki tyypillisist FORTRAN 77 -koodissa kytetyist

COMMON-alueista:
COMMON/EQ/N,NTOT
COMMON/FCALLS/NC
COMMON/TOL/ABSTOL,RELTOL
Seuraavassa on nm COMMON-alueet korvaava moduuli:
284
Fortran 95/2003
MODULE globaalit_muuttujat
IMPLICIT NONE
INTEGER, SAVE :: n, ntot, nc
REAL, SAVE :: abstol, reltol
END MODULE globaalit_muuttujat
Muuttujien mre SAVE on tarpeen, jos moduulin arvojen halutaan silyvn mys proseduurikutsujen vlill! Jos SAVE-mrett ei kytet, silyvt
moduulissa mriteltyjen muuttujien arvot ohjelman suorituksen ajan ainoastaan silloin, kun moduuli otetaan kyttn mys pohjelmassa.
Moduulia voi kytt vaikkapa seuraavasti:
USE globaalit_muuttujat
USE globaalit_muuttujat, ONLY : n, ntot
Ensimminen USE-lause otti kyttn kaikki moduulin oliot. Toisessa lauseessa otettiin kyttn vain muuttujat n ja ntot.
Edell sijoitettiin kaikki globaalit muuttujat samaan moduuliin. Tmn sijasta voi tietysti kytt erillisi moduuleja, joiden kytt vastaa alkuperisten
COMMON-alueiden kytt.
15.7
Fortranin vanhentuvat piirteet
Fortran 90 -standardi sislsi vanhentuviksi merkittyj piirteit (obsolescent

feature). Vanhentuvat piirteet siirrettiin standardin seuraavissa versioissa
poistettujen piirteiden (deleted feature) listalle, jolloin ne eivt en kuulu
standardiin.
Fortran 95 -standardissa mriteltiin seuraavat poistetut piirteet:
reaalilukutyyppiset silmukkamuuttujat
hyppy END IF -lauseeseen lohkon ulkopuolelta
PAUSE-lause
ASSIGN-komento, epsuora hyppylause (assigned goto) sek FORMATlausenumeron sijoittaminen kokonaislukumuuttujaan ASSIGN-lauseella
nH-muotoilukoodit (Hollerith-merkkijonovakiot).
Vanhentuvien piirteiden listalle siirrettiin Fortran 95:ss seuraavat piirteet:
aritmeettinen IF-lause
usean DO-silmukan yhteinen lopetuslause
vaihtoehtoinen paluukohta
haarautuva hyppylause (computed goto)
285
lausefunktiot
suoritettavien lauseiden joukossa olevat DATA-lauseet
oletetun mittaiset merkkijonot (assumed length)
sarakesidonnainen lhdekoodin muoto
CHARACTER*-tyyliset merkkijonojen mrittelyt.
Seuraavassa kuvataan lyhyesti joitakin standardin vanhentuvista ja poistetuista piirteist. Niden kytt tulee vltt.
15.7.1 Aritmeettinen IF-lause

Aritmeettinen IF-lause on kolmisuuntainen hyppylause:
IF (I) 10,20,30
Jos muuttuja I on negatiivinen, hyptn lauseeseen 10; jos I on nolla,

hyptn lauseeseen 20 ja muussa tapauksessa lauseeseen 30.
Aritmeettisen IF-lauseen voi korvata IF-rakenteella.
15.7.2 Hyppy END IF -lauseeseen rakenteen ulkopuolelta

Aikaisemmin seuraava ohjelmakoodi oli sallittua:
100
IF (Y .EQ. 0) GOTO 100

IF (X .GT. 0) THEN
Y = 1.0/X
END IF
Fortran 90 -standardissa tytyy hyppylauseen osoitteena olla END IF -lausetta seuraava lause (esimerkiksi CONTINUE-lause).
Hyppylauseet kannattaa useimmiten korvata kehittyneemmill ohjausrakenteilla.
15.7.3 Reaalilukutyyppiset silmukkamuuttujat

FORTRAN 77 salli DO-rakenteessa reaalilukutyyppiset silmukkamuuttujat.
Tm johtaa helposti laiteriippuvaisuuksiin. Esimerkiksi silmukka
DO x = 0.0, 1.0, 0.1
WRITE (*,*) x
END DO
voidaan suorittaa 10 tai 11 kertaa riippuen reaalilukujen esitystavasta. Reaalilukutyyppisten silmukkamuuttujien sijaan on syyt kytt kokonaislukutyyppisi lausekkeita, koska tllin toistokertojen mr on sama riippumatta liukulukuaritmetiikan tarkkuudesta.
286
Fortran 95/2003
15.7.4 Usean DO-silmukan yhteinen lopetuslause

Vanhoissa koodeissa nkee seuraavan nkisi silmukoita:
100
DO 100 I=2,N
X(I)=1D30
DO 100 II=1,N
A(II,I)=0D0
Tmn sijaan kannattaa kytt END DO -lausetta silmukkojen lopettamiseen. Tt on havainnollistettu kappaleessa 15.5 (sivu 281).
Mys silmukan pttminen muuhun kuin END DO tai CONTINUE-lauseeseen
on mritelty vanhentuvaksi piirteeksi.
15.7.5 ASSIGN-lause ja epsuora hyppylause

Epsuoraa hyppylausetta (assigned goto) on kytetty simuloimaan proseduurikutsua.
Seuraavassa on esimerkki epsuorasta hyppylauseesta:
ASSIGN 100 TO I
GOTO I
Tmn sijaan on syyt kytt joko IF-lausetta tai proseduurin kutsua.

ASSIGN-lausetta on kytetty mys FORMAT-lauseen lausenumeron sijoittamiseen kokonaislukumuuttujaan. Tmn sijaan kannattaa muotoilukoodi sijoittaa merkkityypin muuttujaan tai nimettyyn merkkijonovakioon ja kytt tt tiedonsiirto-operaatioissa.
15.7.6 Vaihtoehtoinen paluukohta

Aliohjelman vaihtoehtoinen paluukohta (alternate return) mahdollisti paluun
proseduurikutsusta erikseen mriteltvn lauseeseen:
100
200
PROGRAM kutsu
...
CALL ali(i, j, *100, *200)
...
CONTINUE
...
CONTINUE
...
END
SUBROUTINE ali(i, j, *, *)
...
RETURN 1
...
RETURN 2
...
END
287
Vaihtoehtoisen paluukohdan sijaan on syyt kytt kokonaislukutyyppist

paluukoodia ja vaikkapa SELECT CASE -rakennetta:
PROGRAM kutsu
...
CALL ali(i, j, koodi)
SELECT CASE(koodi)
CASE(1)
...
END SELECT
END PROGRAM kutsu
15.7.7 PAUSE-lause
PAUSE-lause keskeytt ohjelman suorituksen, kunnes nppint painamalla
annetaan lupa jatkaa suoritusta. Tmn sijaan kannattaa tulostaa kehote
WRITE- tai PRINT-lauseella ja lukea ptteelt syte READ-lauseella merkiksi
siit, ett ohjelman suoritusta saa jatkaa:
CHARACTER(LEN=80) :: rivi
DO
WRITE (*,*) Jatketaanko suoritusta (K,k)?
READ (*,(A)) rivi
rivi = ADJUSTL(rivi)
IF (rivi(1:1) == K .OR. rivi(1:1) == k) EXIT
END DO
15.7.8 Hollerith-merkkijonovakiot
Hollerith-merkkijonovakioita kytettiin osana FORMAT-lauseden muotoilukoodia. Tmn sijaan voi kytt lainausmerkkeihin sijoitettua merkkijonovakiota.
Seuraavassa on esimerkki vanhentuvasta mrittelyst:
100
PRINT 100, X
FORMAT (5HArvo:,F10.6)
Tmn voi esitt selkemmin seuraavasti:

PRINT ("Arvo:",F10.6), x
15.8
Vltettvi Fortranin piirteit
Seuraavia Fortranin piirteit olisi syyt vltt, vaikka kntjt niit yh

ymmrtvt.
288
Fortran 95/2003
Taulukon alkioiden sijoittelujrjestys muistissa (storage association).

Standardi ei en vaadi, ett taulukkojen alkiot talletetaan jossain tietyss jrjestyksess koneen keskusmuistiin. Tm ei olisi edes mahdollista rinnakkaiskoneissa!
COMMON-alueiden kytt.
EQUIVALENCE-lauseen kytt.
BLOCK DATA -yksikkjen kytt.
Proseduuriin vlitettvn taulukon koon ja dimensioiden lukumrn
vristely. Tt on kytetty esimerkiksi vlittmn kaksiulotteinen
taulukko yksiulotteisena vektorina aliohjelmaan. Koska taulukon alkioiden jrjestyst muistissa ei ole mritelty standardissa, tm voi johtaa
pahoihin virhetilanteisiin!
ENTRY-lause.
Ohjelmakoodin sarakesidonnainen syttmuoto.
DOUBLE PRECISION -tyyppi.
Haarautuva hyppylause (computed goto)
Merkkijonon pituuden mrittely tyyliin
CHARACTER*30
Kyt sen sijaan mrittely CHARACTER(LEN=pituus).

Lausefunktiot (statement function). Nm voi korvata sisisill proseduureilla.
Standardifunktioiden erityisnimet (specic name). Kyt sen sijaan standardifunktioiden geneerisi nimi. Siis SIN eik DSIN jne.
Tyypillinen esimerkki vltettvst ja vaarallisesta FORTRAN-koodista on
seuraava tapa vlitt kaksiulotteinen taulukko yksiulotteisena taulukkona
aliohjelmaan:
100
PROGRAM HULLU
INTEGER N
PARAMETER (N = 10)
REAL A(N,N+1)
CALL ALUSTA(A,N,N+1)
WRITE (*,*) A(1,1), A(2,3)
END
SUBROUTINE ALUSTA(V,N,M)
INTEGER N, M
REAL V(N*M)
INTEGER I
DO 100 I = 1, N*M
V(I) = I
CONTINUE
END
289

1.000000
22.00000
Parempi tapa esitt edellinen alustusoperaatio on seuraava:

PROGRAM hullu
IMPLICIT NONE
REAL, DIMENSION(n,n+1) :: a
CALL alusta(a)
WRITE (*,*) a(1,1), a(2,3)
CONTAINS
SUBROUTINE alusta(taulukko)
IMPLICIT NONE
REAL, DIMENSION(:,:), INTENT(OUT) :: taulukko
INTEGER :: i, n, m
n = SIZE(taulukko,1)
m = SIZE(taulukko,2)
taulukko = RESHAPE( (/ (i, i = 1, n*m) /), &
(/ n, m /) )
END PROGRAM hullu
Tss kytettiin standardifunktiota RESHAPE taulukon alustamiseen.
Harjoitustehtvi
1. Muunna seuraava sarakesidonnaista FORTRAN 77 -syttmuotoa kyttv ohjelma vapaaseen syttmuotoon. Kyt ohjelman alussa lausetta IMPLICIT NONE ja silmukoissa ohjausrakennetta DO ... END DO. Sisenn ohjelmakoodi selkesti.
PROGRAM SILMUKAT
REAL X(100,100), Y(100), Z(100), A, S
INTEGER I, J, K
3
2
5
DO 1 J = 1, 100
Y(J) = 0.1*J
DO 1 I = 1, 100
X(I,J) = 1.0 + Y(J)
CONTINUE
DO 2 J = 1, 100
S = 0.0
DO 3 I = 1, 100
S = S + X(I,J)
CONTINUE
Z(J) = SQRT(Y(J))/S
CONTINUE
DO 5 J = 1, 100
IF (Z(J) .LT. 0.001) Z(J) = 0.0
A = Z(1)
K = 1
290
Fortran 95/2003
DO 6 I = 2, 100
IF (Z(I) .GT. A) THEN
K = I
A = Z(I)
ENDIF
CONTINUE
WRITE (*,*) A, K
END
2. Muunna edellisen tehtvn ohjelmakoodi taulukkosyntaksiksi jos mahdollista. Kyt Fortran 90 -kielen sisnrakennettuja funktioita SUM,
MAXVAL ja MAXLOC.
3. Esit seuraava haarautuvaa hyppylausetta kyttv ohjelmakoodi IFrakennetta kytten:
INTEGER EHTO
REAL X, Y, Z
10
11
GO TO (10, 11, 10) EHTO

Y = Z
X = Y + 2
X = X**2
X = X + 3
16. Fortran 2003
16
291
Fortran 2003
Nykyinen Fortran-standardi on nimeltn Fortran 2003. Standardi on huomattava laajennus verrattuna aiempiin standardeihin. Esitmme tiiviin katsauksen standardin uusiin piirteisiin.
Uusien piirteiden mrst johtuen standardia tysin noudattavia kntji
ei tt kirjoittaessa (vuoden 2007 kevll) ole saatavilla. Sosittelemme, ett Fortran-ohjelmoinnissa kytetn Fortran 95 -standardin piirteit, jotka
sisltyvt Fortran 2003:een.
Seuraava standardi, tynimeltn Fortran 2008, on jo valmisteilla. Tm
standardi tuo lis uusia piirteit Fortran-kieleen. Nit uusia ominaisuuksia
ymmrtvi kntji saamme odottaa luultavasti useita vuosia.
16.1
Fortran 2003:n trkeimmt lisykset ja

parannukset
Fortran 2003 on laaja pivitys kielen standardiin ja sislt runsaasti uudistuksia:

parannuksia rakenteisten tyyppien ksittelyyn: parametrisoidut tyypit,
parannetut alustimet ja lopettajat
tuki olio-ohjelmoinnille: tyyppien laajennukset ja periytyminen, polymorsmi, dynaaminen tyyppien varaus ja tyyppeihin sidotut proseduurit
datan ksittelyn parantaminen: varattavat komponentit, myhstetyt
tyyppiparametrit, volatile-mre, laajennetut alustimet ja standardiproseduurit
IEEE 754 -standardin mukainen aritmeettisten keskeytysten ksittely
(yli- ja alivuoto jne.)
yhteensopivuus C-kielen kanssa
proseduureihin osoittavat muuttujat
kansainvlisten merkkivalikoimien kytt: ISO 10646, neljn tavun merkist
292
Fortran 95/2003
parannettu tuki kyttjrjestelmn ominaisuuksille: komentoriviargumentit, ympristmuuttujat, virhetilanteet.
16.1.1 Rakenteisten tyyppien rarametrisointi

Fortran 95:ss standardityypeill on lajiparametri ja merkkijonoilla lisksi
pituusparametri. Fortran 2003:ssa rakenteisissa tyypeiss voi kytt parametreja, jotka mritelln vasta kytn yhteydess.
Seuraavassa on esimerkki matriisityypist, jolla on lajiparametri:
TYPE matriisi(laji, m, n)
INTEGER, KIND :: laji = SELECTED_REAL_KIND(10)
INTEGER, LEN :: m, n
REAL(laji), DIMENSION(m,n) :: alkiot
END TYPE
Tmn tyyppinen olio voidaan ottaa kyttn seuraavasti:

TYPE(matriisi(SELECTED_REAL_KIND(6), 100, 101)) :: x
Tuloksena on 100 101 -taulukko, jonka alkiot ovat reaalilukuja.
16.1.2 Mreiden arvojen alustus

Fortran 95 -standardissa ei ollut mahdollista antaa rakenteisten tyyppien
mreille oletusarvoa. Nyt tm on mahdollista:
TYPE date
INTEGER :: day
CHARACTER(LEN = 5) :: month
INTEGER :: year = 1994
END TYPE date
Tss vuoden oletusarvoksi asetettiin 1994. Mrittely voi kytt seuraavasti:

TYPE(date), PARAMETER :: &
today = date(21, Feb., 1995)
16.1.3 Sytn ja tulostuksen parannukset

Fortran 2003:ss on parannettu sytt ja tulostusta seuraavasti:
asynkroninen tiedonsiirto: ohjelma voi jatkaa suoritustaan sytn ja
tulostuksen aikana
sytevirran (stream) ksittely: tiedostoa voi ksitell ilman tietuerakenteen kytt
kyttjn mrittelemt tiedonsiirto-operaatiot rakenteisille tyypeille
16. Fortran 2003
293
kyttjn mrittelemt pyristysoperaatiot formatointimuunnoksissa

FLUSH-lause
nimetyt vakiot valmiiksi yhdistetyille kanaville (preconnected unit)
syttja tulostuslauseiden avainsanojen yhtenistminen
psy sytn ja tulostuksen virheilmoituksiin.
16.1.4 Yhteensopivuus C-kielen kanssa

Fortran 2003:ssa parannetaan yhteensopivuutta C-kielen kanssa sisnrakennetulla moduulilla ISO_BINDING_C sek mreill BIND ja VALUE. Useimmat Fortran-kntjt ovat tukeneet C-kielen kytt, mutta eivt siirrettvll tavalla.
Parannnukset liittyvt seuraaviin piirteisiin:
muuttujatyypit: perustyypit, rakenteiset tyypit ja osoittimet
sek skalaari- ett taulukkomuuttujat
proseduurit (tunnetun kutsumuodon avulla).
16.1.5 Osoittimet proseduureihin

Proseduuriosoittimilla voidaan dataan liitt datan ksittelyn toiminnallisuuksia. Olio-ohjelmoinnin termeill kyseess on metodien liittminen dynaamisesti olioihin. Seuraavassa on tst esimerkki:
PROCEDURE(pros), POINTER :: p => NULL()
Tss proseduuri p viittaa aluksi tyhjn ja sill on sama kutsumuoto kuin

proseduurilla pros.
Jos kytettviss ei ole valmiiksi sopivaa kutsumuotoa, voidaan mritell
abstrakti kutsumuoto:
ABSTRACT INTERFACE
COMPLEX FUNCTION f(x,y,z)
COMPLEX, INTENT(IN) :: x, y, z
END FUNCTION
END INTERFACE
Proseduuriosoittimia voidaan kytt hyvksi rakenteisissa tietotyypeiss:

TYPE matriisi(laji, m, n)
INTEGER, KIND :: laji = SELECTED_REAL_KIND(10)
INTEGER, LEN :: m, n
REAL(laji), DIMENSION(m,n) :: alkiot
PROCEDURE (lu_hajotelma), POINTER :: ratkaisija
END TYPE
294
Fortran 95/2003
Tt tyyppi voidaan kytt seuraavasti:

TYPE(matriisi(SELECTED_REAL_KIND(6), 100, 101)) :: x
...
CALL x%ratkaisija( ... )
16.1.6 Rakenteisen tyypin lopettaminen

Rakenteisissa tyypeiss voi kytt FINAL-aliohjelmia, joilla voidaan hoitaa
tarvittavat toimenpiteet kun kyseisen tyypin olio lakkaa olemasta:
TYPE t
...
CONTAINS
FINAL :: lopetus1, lopetus2
END TYPE t
Kun olio lopetetaan, kutsutaan sit lopetusaliohjelmaa, jonka argumentit

vastaavat rakenteisen tyypin alkioiden tyyppej ja ulottuvuuksia.
16.1.7 Proseduurien liittminen tyyppeihin

Rakenteisen tyypin komponentti voi olla proseduuri, johon viitataan samoin
kuin normaalisti rakenteisen tyypin alkiohin:
TYPE t
...
CONTAINS
PROCEDURE :: pros1 => proseduuri
PROCEDURE :: pros2
GENERIC :: g => aliohj1, aliohj2, aliohj3
END TYPE
Tss proseduureja voidaan kutsua seuraavasti, jos x on kyseist rakenteista

tyyppi:
CALL x%pros1(...)
CALL x%g(...)
Geneeriseksi mritellyn proseduurin x%g tytyy kutsuttaessa olla yksiksitteinen argumenttiensa suhteen.
16.1.8 PASS-mre
Kun rakenteisen tyypin alkioon liittyv proseduuria kutsutaan, tarvitsee se
usein psyn kyseisen olion sisltn. Oletuksena olio vlitetn ensimmisen argumenttina:
CALL x%pros1(x,y)
16. Fortran 2003
295
Tss x vlitetn aliohjelmaan pros1 ensimmisen argumenttina ja x ja

y ovat toinen ja kolmas argumentti. Tllin sanotaan, ett proseduurilla on
PASS-mre. Jos nin ei haluta, voidaan kytt NOPASS-mrett.
16.2
Fortran 2003 ja olio-ohjelmointi
Fortran 2003:n suurimpana ksitteellisen uudistuksena on tuki olio-ohjelmoinnin periaatteiden toteuttamiseksi Fortran-kielell. Kuitenkaan Fortran 2003 -kielt ei voi pit varsinaisesti olio-ohjelmointikielen vaan pikemminkin jonkinlaisena semi-oliokielen.
Olio-ohjelmoinnin paradigma perustuu ksiteanalyysiin, jossa kuvataan sovelluskohteen loogiset yksikt sek niden vliset suhteet perustuen kohdemaailman tietomalliin. Tm paradigma eroaa perinteisemmst proseduraalisesta lhestymistavasta eli niin sanotusta osittavasta ohjemistosuunnittelusta (top down), jossa modularisoinnin periaatteita noudattamalla tarkennetaan toimintoja aliohjelmien ja perusrakenteiden kautta aina yksittisten
kskyjen tasolle asti. Kiinnostunut lukija lyt mainion johdatuksen olioajatteluun esimerkiksi Koskimiehen teoksesta [Kos97].
Osittavan ohjelmistosuunnittelun merkittvin etu suhteessa kohdemaailman tietomalliin perustuvaan lhestymistapaan on se, ett ohjelmiston kehittminen etenee ainakin pieniss sovelluksissa nopeammin. Toisaalta osittavan ohjelmistosuunnittelun merkittvin heikkous on se, ett ohjelmiston
korkean tason muutokset heijastuvat suureen osaan ohjelmistoa eli ohjelmiston rakenne on epjatkuva.
Valistuneen oliomallintamisen ern suurimpana etuna nhdnkin se, ett ohjelmiston muutostarpeet kohdentuvat paikallisiin komponentteihin ja
niiden toteutukseen. Tllin paikalliset muutokset eivt propagoidu ympri ohjelmistoa eli ohjelmiston rakenne on jatkuva, mik helpottaa ohjelmiston yllpitoa. Lisksi valistunut olio-ohjelmointi mahdollistaa ohjelmakoodin useissa sovelluskohteissa esiintyvien korkean tason komponenttien
jlleenkytn (reusability). Usein esiintyvist abstrakteista komponenteista
kytetn nimityst suunnittelumalli (design pattern [GHJV95]).
Kurinalaisella ohjelmoinnilla oliomallintamisen oppeja voidaan soveltaa
mys proseduraalisilla kielill ohjelmoitaessa. Tosin tllin ohjelmointi on
teknisesti tylmp kuin puhtaammilla oliokielill, sill oliokielet mahdollistavat teknisesti helpommin perintmekanismin toteuttamisen, abstraktien tietotyyppien (luokkien) kuvaamisen ja niden ilmentymien (olioiden)
kytn osana dynaamista ymprist. Lisksi klassisen tietoabstraktion perusperiaatteen erota toteutus ja tietorakenteen operaatiot toisistaan noudattaminen on yleens jouhevinta oliokielill.
Fortran 95 -kieless luokka vastaa lhinn moduulin eli siihen kuuluvien
toimintojen ja tietorakenteiden ksitett (abstrakti tietotyyppi). Periytymismekanismia ei tueta suoraan kielen korkealla tasolla. Fortran 2003:ssa rakenteisille tyypeille voi mritell perinthierarkian.
296
Fortran 95/2003
16.3
Fortran 2003:n tuki olio-ohjelmoinnille
Fortran 2003:een sisltyy viisi olio-ohjelmointia helpottavaa ominaisuutta:

tyyppien laajentaminen: tietty tyyppi voi laajentaa toista
polymorsmi: muuttujan tyyppi voi muuttua ajon aikana
dynaaminen tyyppien varaaminen
SELECT TYPE -rakenne
tyyppeihin liitetyt proseduurit.
Fortran 2003 lhestyy ominaisuuksiltaan varsinaisia oliokieli, vaikkei sellainen tydess merkityksess olekaan.
16.3.1 Laajennetut tyypit: perintmekanismi rakenteisille

tyypeille
Rakenteinen tyyppi, jolla ei ole mrett SEQUENCE tai BIND(C), on laajennettavissa. Tss esimerkki:
TYPE, EXTENDS(matriisi) :: matriisi_hajotelma
LOGICAL :: laskettu = .false.
REAL(matriisi%laji) :: hajotelma(matriisi%m, matriisi%n)
END TYPE
Laajennettua tyyppi voi laajentaa edelleen.

Fortran 2003:n olio-ominaisuudet rakentuvat suoraan Fortran 95:n tyyppimrittelyjen varaan. Seuraavassa on esimerkki rakenteisesta tyypist ja laajennetusta tyypist:
TYPE :: vector_2d
REAL :: x, y
END TYPE vector_2d
TYPE, EXTENDS(vector_2d) :: vector_3d
REAL :: z
END TYPE vector_3d
Niden mrittelyjen ansiosta voimme luoda kaksi- ja kolmiulotteisia vektoreita vastaavat muuttujat v2d ja v3d:
TYPE(vector_2d) :: v2d
TYPE(vector_3d) :: v3d
Muuttujan v3d alkioihin voi viitata seuraavasti: v3d%x, v3d%y ja v3d%z.

Voimme tmn jlkeen mritell funktioita, jotka hyvksyvt argumentikseen tyypin vector_2d muuttujia sek tst tyypist laajennettuja muuttujia:
16. Fortran 2003
297
REAL FUNCTION argument(v)

IMPLICIT NONE
CLASS(vector_2d) :: v
argument = ATAN2(v%y,v%x)
END FUNCTION
Vastaavasti seuraava funktio hyvksyy tyypin vector_3d sek tst tyypist

laajennetut tyypit:
REAL FUNCTION azimuth(v)
IMPLICIT NONE
CLASS(vector_3d) :: v
azimuth = ATAN2(v%z,argument(v))
END FUNCTION
16.3.2 Monimuotoisuus
Fortran 2003 -kielen muuttujat voivat olla monimuotoisia (polymorsia).
Monimuotoisuudella tarkoitetaan, ett muuttuja voi viitata annettua rakenteista tyyppi vastaavaan ilmentymn (eli olioon) sek tmn ilmentymn
tyypin laajennettujen tyyppien ilmentymiin. Tllin alkioiden valinta liittyy
dynaamisesti ilmentymn tyyppiin, eik muuttujan tyyppiin. Seuraava esimerkki selvent monimuotoisuuden ideaa:
CLASS(vector_2d), POINTER :: p2
CLASS(vector_3d), POINTER :: p3
TYPE(vector_2d), TARGET :: t2
TYPE(vector_3d), TARGET :: t3
Tmn jlkeen seuraavat osoitinsijoitukset ovat luvallisia:

p2
p2
p3
p2
=>
=>
=>
=>
t2
t3
t3
p3
Sijoitus p3 => t2 on sen sijaan laiton, sill muuttujaa t2 ei ole johdettu

tyypist vector_3d. Vastaavasti sijoitus p3 => p2 on laillinen vain siin
tapauksessa, ett osoitinmuuttuja p2 osoittaa tyypin vector_3d olioon tai
tst tyypist laajennettuun olioon.
16.3.3 SELECT TYPE -rakenne

Monimuotoisten olioiden ksittelyss tarvitaan ohjausrakenne, jolla voidaan
ohjelman ajon aikana valita oikea toimenpide suoritettavaksi. Seuraavassa
on esimerkki SELECT TYPE -rakenteen kytst:
TYPE :: piste
REAL :: x, y
END TYPE
TYPE, EXTENDS(piste) :: piste3d
REAL :: z
298
Fortran 95/2003
END TYPE
TYPE, EXTENDS(piste) :: rgb_piste
INTEGER :: r, g, b
END TYPE
TYPE(piste), TARGET :: p
TYPE(piste3d), TARGET :: p3d
TYPE(rgb_piste), TARGET :: pc
CLASS(piste), POINTER :: p_olio
p_olio => pc
SELECT TYPE (t => p_olio)
TYPE IS (piste3d)
PRINT *, t%x, t%y, t%z
CLASS IS (piste)
PRINT *, t%x, t%y
END SELECT
SELECT TYPE -rakenteessa tutkitaan ensiksi vastaavuutta TYPE IS -kohtien

kanssa, ja jos vastaavuutta ei lydy, CLASS IS -kohtien kanssa.
16.4
Listietoa
Fortran 2003 -kielen ksikirjana voi kytt teosta Fortran 95/2003 Explained [MRC04]. Artikkelissa The New Features of Fortran 2003 [Rei] kuvataan
tiiviiss muodossa Fortran 2003:n uudet piirteet. Johdatukseksi kieleen sek
oppikirjaksi sopii teos Introduction to Programming with Fortran [CS06].
17. Rinnakkaislaskenta HPF:ll ja OpenMP:ll
17
17.1
299
Rinnakkaislaskenta
HPF:ll ja OpenMP:ll
Vlineit rinnakkaislaskentaan
HPF (High Performance Fortran) on Fortran 95:een perustuva datarinnakkainen ohjelmointikieli. Datarinnakkaisessa ohjelmoinnissa suoritetaan samoja operaatioita tietorakenteen (tyypillisesti taulukon) eri alkioille. Siten HPF
ei ole rinnakkaislaskennan yleistykalu, mutta se sopii erityisesti tehtviin,
joissa suoritetaan snnllisi taulukko-operaatioita. HPF soveltuu hienosyiseen (silmukkatason) rinnakkaistamiseen, mutta tllin rinnakkaiskoneessa
tytyy olla nopea viestinvlitys prosessorien vlill.
Kappaleessa 17.3 sivulla 305 kerrotaan rinnakkaistamisesta OpenMP:n avulla. Tm standardi soveltuu vain yhteisen muistin koneille, mutta on usein
HPF: tehokkaampi ja monipuolisempi rinnakkaistusvline.
Rinnakkaistamisen voi tehd mys viestinvlityst kytten. Esimerkiksi MPI
(Message-Passing Interface) mahdollistaa rinnakkaisohjelmoinnin viestinvlityst kytten [HM01]. Mys vanhempaa PVM-jrjestelm voi kytt rinnakkaisohjelmointiin [Saa95].
17.2
HPF-ohjelmoinnin perusteet
HPF-ohjelmointi poikkeaa Fortran 95:st pasiallisesti vain datan jakamista ja taulukko-operaatioiden rinnakkaistusta ohjaavien kntjdirektiivien
osalta.
Ohjelmoija jakaa taulukot prosessoreille kntjdirektiivien avulla, ja kntj huolehtii kaikesta tarvittavasta viestinvlityksest. Koska direktiivit ovat
syntaksiltaan Fortran 95 -kommentteja, ohjelma voidaan periaatteessa knt mys Fortran 95 -kntjll, jolloin tuloksena on HPF-rinnakkaisversion
kanssa samoja tuloksia tuottava tavallinen perkkisohjelma.
Kntjdirektiivit ovat esimerkiksi muotoa
!HPF$ direktiivi
300
Fortran 95/2003
Lause USE HPF_LIBRARY ohjelman alussa mahdollistaa HPF-kirjaston aliohjelmien kytn. Monipuolisten bitinksittely- ja taulukkorutiinien lisksi kirjastossa on funktioita, joilla saa tietoa prosessorihilasta ja taulukoiden jaosta.
Seuraavassa on esimerkki yksinkertaisesta HPF-ohjelmasta:
PROGRAM piste
IMPLICIT NONE
INTEGER :: n
REAL, DIMENSION(:), ALLOCATABLE :: a, b
REAL :: d
!hpf$ distribute a(block)
!hpf$ align b(:) with a(:)
WRITE (*,*) Input the number of points:
READ (*,*) n
ALLOCATE (a(n), b(n))
a = 1.0
b = 2.0
d = SUM(a*b)
WRITE (*,*) d
END PROGRAM piste
Ohjelma laskee kahden vektorin pistetulon. Vektori a jaetaan yht suuriin

osiin eri prosessorien kesken:
!HPF$ DISTRIBUTE A(BLOCK))
Lause
!HPF$ ALIGN B WITH A
puolestaan mr, ett vektoreiden B ja A vastinalkiot tallennetaan samoihin prosessoreihin. Huomaa, ett Fortranin standardifunktio SUM on HPF:ss
rinnakkaistettu.
17.2.1 HPF-esimerkki: Poissonin yhtl

Seuraavassa havainnollistetaan yksinkertaisella esimerkkiohjelmalla HPF:n
tyypillisimpi piirteit. Ohjelma ratkaisee Poissonin yhtln
2u
2u
+
= f (x, y)
x 2
y 2
neliss iteratiivisesti dierenssimenetelmll. Esimerkkiohjelmaa ei ole mitenkn optimoitu.
PROGRAM poistesti
USE poisson, ONLY : p, init, sweep, diff
IMPLICIT NONE
REAL(KIND=p) :: diff, dnorm = 1.0, tol = 1.0e-6
REAL(KIND=p), DIMENSION(0:n+1,0:n+1) :: a, b, f
INTEGER :: i = 0, maxiter = 500

!HPF$ DISTRIBUTE a(BLOCK,BLOCK)
!HPF$ ALIGN b(:,:) WITH a(:,:)
!HPF$ ALIGN f(:,:) WITH a(:,:)
CALL init(a,b,f,n)
DO WHILE (dnorm > tol .AND. i <= maxiter)
CALL sweep(a,f,b,n)
CALL sweep(b,f,a,n)
dnorm = diff(a,b,n)
IF (MOD(i,50) == 0) WRITE (*,*) Erotus: , dnorm
i = i + 1
END DO
END PROGRAM poistesti
Varsinaiset laskentarutiinit mritelln moduulissa poisson:

MODULE poisson
IMPLICIT NONE
INTEGER, PARAMETER:: p = SELECTED_REAL_KIND(12,50)
CONTAINS
Rutiinien init, sweep ja diff mrittely
END MODULE POISSON
Tehtv alustetaan rutiinilla init:

SUBROUTINE init(a, b, f, n)
IMPLICIT NONE
INTEGER :: n, i, j
REAL(KIND=p), DIMENSION(0:n+1,0:n+1), INTENT(OUT) :: &
a, b, f
!HPF$ DISTRIBUTE a(CYCLIC,*)
!HPF$ ALIGN b(:,:) WITH a(:,:)
!HPF$ ALIGN f(:,:) WITH a(:,:)
a = 0.0_p
b = 0.0_p
f = 0.0_p
!HPF$ INDEPENDENT, NEW(i)
DO j = 1, n
!HPF$ INDEPENDENT
DO i = 1, n
f(j,i) = EXP(-(REAL(i)/(n+1)-0.5_p)**2 - &
(REAL(j)/(n+1)-0.5_p)**2)
END DO
END DO
END SUBROUTINE init
Iteraatiomatriisi pivitetn seuraavasti:

SUBROUTINE sweep(a, f, b, n)
IMPLICIT NONE
INTEGER :: n, i, j
REAL(KIND=p), DIMENSION(0:n+1,0:n+1), INTENT(IN) :: a, f
301
302
Fortran 95/2003
REAL(KIND=p), DIMENSION(0:n+1,0:n+1), INTENT(OUT) :: b

REAL(KIND=p) :: h
!HPF$ INHERIT a
!HPF$ INHERIT b
!HPF$ INHERIT f
h = 1.0/REAL(n+1)
FORALL (i = 1:n, j = 1:n)
b(i,j) = 0.25_p*(a(i-1,j) + a(i,j+1) + a(i,j-1) + &
a(i+1,j)) - h*h*f(i,j)
END FORALL
END SUBROUTINE sweep
Perkkisten tilojen erotusten summa lasketaan seuraavasti:

FUNCTION diff(a, b, n) RESULT(d)
IMPLICIT NONE
INTEGER :: n, i, j
REAL(KIND=p), DIMENSION(0:n+1,0:n+1), INTENT(IN) :: a, b
REAL(KIND=p), DIMENSION(0:n+1,0:n+1) :: c
REAL(KIND=p) :: d
!HPF$ DISTRIBUTE a *(BLOCK,BLOCK)
!HPF$ DISTRIBUTE b *(BLOCK,BLOCK)
!HPF$ ALIGN c(:,:) WITH a(:,:)
c = 0.0_p
FORALL (i = 1:n, j = 1:n)
c(i,j) = (a(i,j)-b(i,j))**2
END FORALL
d = SUM(c)
END FUNCTION diff
Ohjelma voidaan knt ja ajaa CSC:n Cray T3E -rinnakkaiskoneella seuraavasti:

% module load pghpf
% pghpf poisson.f90 poistest.f90
poisson.f90:
poistest.f90:
Linking:
% mpprun -n 4 ./a.out
Erotus: 2.77748137513380882E-5
Erotus: 2.40804630593270039E-5
Erotus: 2.23112050510325605E-5
...
Erotus: 1.55501436889230665E-5
Erotus: 1.48850843733872855E-5
17.2.2 Taulukoiden jakaminen prosessoreille HPF:ll

Datarinnakkaisuus perustuu HPF:ssa taulukoiden jakamiseen prosessoreille
DISTRIBUTE-direktiivill. Oletusarvoisesti dataa ei jaeta. Esimerkiss poh-
303
jelman taulukko a jaetaan lohkoittain. Mys useat muut hajautukset ovat

mahdollisia. Direktiivi
!HPF$ DISTRIBUTE a(BLOCK,*)
jakaa taulukon vaakalohkoihin. Asteriski (*) hajautusmuotona tarkoittaa

siis, ett kyseinen dimensio jtetn jakamatta. Muotojen BLOCK ja * lisksi kytettviss on CYCLIC, joka jakaa kohteena oleva taulukon dimension
jaksollisesti. Esimerkiksi direktiivi
!HPF$ DISTRIBUTE a(CYCLIC,*)
antaa taulukon ensimmisen rivin ensimmiselle prosessorille, toisen toiselle ja niin edelleen. Jos ohjelmaa ajettaisiin neljll prosessorilla, rivi viisi
olisi taas ensimmisell prosessorilla.
Direktiivin DISTRIBUTE lisksi taulukoiden jakamiseen voi kytt direktiivi ALIGN, jolla taulukko voidaan jakaa jo jaetun taulukon avulla. Esimerkkiohjelmassa globaalit taulukot b ja f on hajautettu samoin kuin a. Formaatilla * on sama merkitys kuin DISTRIBUTE-direktiivin yhteydess. Niinp
esimerkiksi direktiivi
!HPF$ ALIGN b(:,*) WITH a(*,:)
liitt taulukon b rivit taulukon a sarakkeisiin. Taulukon b alkioiden lopullinen jakautuminen prosessorien kesken riippuu taulukon a hajautuksesta.
Direktiiveill DISTRIBUTE ja ALIGN voi toteuttaa erittin monipuolisia datan
jakoja [KLS+ 94]. Jakoa ja kohdistusta voi mys muuttaa ohjelman suorituksen aikana direktiiveill REDISTRIBUTE ja REALIGN. Tm ei kuitenkaan ole
suositeltavaa ohjelman suorituskyvyn kannalta.
17.2.3 Taulukoiden jako aliohjelmissa

Aliohjelmat voivat jakaa argumenttitaulukkonsa pohjelmasta riippumatta. Edellisten esimerkkien aliohjelmissa on sovellettu erilaisia jakoja lhinn
niiden esittelemiseksi. Datan jakamiseen on kolme tapaa: preskriptiivinen,
transkriptiivinen ja deskriptiivinen.
Preskriptiivisess jaossa aliohjelma vaatii, ett argumentin jako on aliohjelman oman mrittelyn mukainen. Jos jako on erilainen, suoritetaan muunnos automaattisesti. Esimerkki preskriptiivisest jaosta on edell aliohjelmassa init.
Datan uudelleen jakaminen hidastaa ohjelman suoritusta. Tmn estmiseksi voi kytt transkriptiivista jakoa ja kirjoittaa aliohjelman siten ett
parametrin hajautus saa olla mielivaltainen.
Transkriptiivinen jako tarkoittaa argumentin jaon perimist pohjelmasta
(INHERIT-direktiivi). Tllin kaikki jaot kelpaavat ja muunnoksia ei tarvita.
Huomaa, ett tm mekanismi vaatii aliohjelmalta yleisyytt, mik vaikeuttaa optimointia. Aliohjelmassa sweep (sivu 301) on transkriptiivinen jako.
Deskriptiivinen jako vakuuttaa kntjlle, ett aliohjelmalle vlitetyn argumentin jako on sama kuin aliohjelmassa mritelty. Nin muunnoksia ei
304
Fortran 95/2003
tarvita. Deskriptiivisest jaosta on esimerkki aliohjelmassa diff (huomaa

merkki * direktiivin DISTRIBUTE yhteydess). INTERFACE-rakenteen avulla
voi tllaisellekin aliohjelmalle vlitt jaoltaan mielivaltaisia argumentteja.
Suorituskyvyn kannalta aliohjelmien datan jako on erittin trke. Harkitsematon jako voi aiheuttaa paljon kopiointia, mik saattaa hidastaa ohjelmaa
huomattavasti. Suositeltavaa on kytt preskriptiivist jakoa ja INTERFACElohkoja. INTERFACE-rakenne antaa kntjlle enemmn tietoa, mik edist
tehokkaamman koodin tekemist ja virheentarkistusta. Mys INTENT-mreet aliohjelmissa auttavat kntj optimoinnissa.
17.2.4 Datarinnakkaisuus
HPF:n datarinnakkaisuus toteutuu seuraavilla tavoilla:
Fortran 95:n taulukko-operaatiot ja -sijoitukset (WHERE-rakenne mukaan
lukien). Esimerkkiohjelmassa taulukkojen alustaminen nollalla initaliohjelmassa tapahtuu rinnakkain.
Fortran 95:n taulukkofunktiot. Esimerkiksi funktiossa diff taulukon
alkioiden summa lasketaan rinnakkaisesti SUM-funktiolla.
HPF-kirjaston taulukkofunktiot. Moduuli HPF_LIBRARY sislt monia
funktioita mm. taulukoiden reduktioon ja lajittelemiseen.
FORALL-lause. Vaikka FORALL-lause muistuttaa silmukkaa, oikeampi tulkinta on pit sit yleistettyn rinnakkaisena taulukkosijoituksena. Sijoituslauseen oikean puolen arvot lasketaan ensin kaikilla indeksien arvoilla, ja sijoitus tapahtuu vasta tmn jlkeen. Sek evaluointi ett sijoitus tehdn rinnakkain. Esimerkin aliohjelmissa diff ja sweep taulukkosijoitukset on toteutettu FORALL-lauseilla.
INDEPENDENT-direktiivi DO- ja FORALL-lauseiden yhteydess. DO-silmukoiden rinnakkaistamiseen kytetn INDEPENDENT-direktiivi, jolla ohjelmoija kertoo kntjlle, ett silmukan eri kierroksilla suoritettavat
operaatiot ovat toisistaan riippumattomia. Koska tm on rinnakkaistamisen edellytys, kaikkia DO-silmukoita ei voi rinnakkaistaa. Tyypillinen
rinnakkaistumaton silmukka on
DO i = 1,n
a(i) = a(i-1)
END DO
Tss suoritusjrjestys vaikuttaa lopputulokseen.

Aliohjelmassa init on kytetty INDEPENDENT DO -rakennetta. Ulompaa silmukkaa vastaavassa INDEPENDENT-direktiiviss on listietoa antava NEWlause, jonka avulla voidaan rinnakkaistaa esimerkiksi tilapisi muuttujia
sisltvi silmukoita. NEW-lauseessa mritellyt muuttujat ovat iknkuin
silmukan sisisi muuttujia, joita ei ole mritelty sen ulkopuolella. Tss
tapauksessa NEW(i) tarvittiin siskkisen silmukan toteuttamiseksi.
305
FORALL-lauseen yhteydess ohjelmoija voi kertoa INDEPENDENT-direktiivill

kntjlle, ett eri indeksien arvoja vastaavat evaluaatiot ja sijoitukset ovat
riippumattomia. Nin synkronointi evaluaatio- ja sijoitusvaiheiden vliss
on tarpeeton, ja ohjelman suoritus voi tietyiss tapauksissa nopeutua.
INDEPENDENT-direktiivi antaa kntjlle lisinformaatiota ja mahdollistaa
siten tehokkaamman koodin tekemisen. INDEPENDENT-direktiivi ei saa muuttaa DO- tai FORALL-lauseen merkityst.
17.2.5 EXTRINSIC-aliohjelmat
EXTRINSIC-aliohjelmien avulla HPF:n voidaan liitt muilla ohjelmointikielill ja rinnakkaisohjelmointimalleilla toteutettuja osia. Kytettviss olevat liittymt riippuvat HPF-toteutuksesta.
EXTRINSIC-aliohjelman kutsussa prosessorit saavat omat osansa taulukoista, ja ohjelmoijan on itse huolehdittava tarvittavasta viestinvlityksest prosessorien kesken.
17.2.6 HPF:n etuja ja haittoja

HPF-ohjelmoinnin helppous on seuraus siit, ett kntj huolehtii viestinvlityksest. Toisaalta ohjelmoijan kontrolli samalla vhenee.
Hyv kytttapa HPF:lle on prototyyppityskentely. Koska HPF-ohjelmointi
on helppoa, ensimminen versio rinnakkaisohjelmasta voidaan laatia nopeasti HPF:ll. Jos saatu suorituskyky ei riit, seuraava askel on siirtyminen
viestinvlitysohjelmointiin. Erityisen hydyllinen piirre tllaisessa tyskentelyss on mahdollisuus kokeilla erilaisia tapoja jakaa data prosessien kesken kytten HPF:n DISTRIBUTE- ja ALIGN-direktiivej.
17.2.7 Listietoja HPF:st

HPF:n ksikirja on teos The High Performance Fortran Handbook [KLS+ 94].
17.3
OpenMP: rinnakkaislaskenta yhteisen

muistin koneissa
OpenMP on rinnakkaislaskennan uusi ohjelmointimalli yhteisen muistin tietokoneille. OpenMP mrittelee joukon direktiivej, kirjastorutiineja ja ympristmuuttujia, joita voidaan kytt Fortran- ja C/C++-ohjelmien rinnakkaistamiseen.
Yhteisen muistin koneissa jokainen prosessori nkee koko muistiavaruuden. Rinnakkaisohjelmoinnin standardi, joka hydyntisi yhteisen muistin
306
Fortran 95/2003
arkkitehtuuria, on puuttunut. OpenMP pyrkii tyttmn tmn aukon ja on

varteenotettava vaihtoehto MPI:lle ja HPF:lle.
Message Passing Interface (MPI) soveltuu luonnollisemmin hajautetun muistin koneille kuten Cray T3E:lle, vaikka sit voidaan kytt mys yhteisen
muistin koneissa. Viestinvlitykseen pohjautuvana kirjastona MPI on parhaimmillaan tehokas, mutta tyls ja suhteellisen matalan tason ohjelmointitykalu.
Datarinnakkainen ohjelmointikieli High Performance Fortran (HPF, katso
kappaletta 17.2 sivulla 299) on periaatteessa helppo ja nopea rinnakkaistamistykalu, mutta ei useimmissa sovelluksissa tarjoa optimaalista suorituskyky.
OpenMP:n tavoite on tarjota joustavammin MPI:n tehokkuus ja HPF:n ohjelmoinnin helppous. Samassa sovelluksessa voidaan mys kytt sek
OpenMP:t ett MPI:t.
Rinnakkaistaminen on mahdollista OpenMP:ll sek hienolla ett karkealla
tasolla. OpenMP sallii periaatteessa mys dynaamisen ja siskkisen rinnakkaisten sikeiden luomisen.
OpenMP:t tukevat useat laite- ja ohjelmistovalmistajat, muun muassa Compaq/Digital, Intel, IBM, Cray/SGI, ANSYS, Fluent ja NAG.
17.3.1 Kntjdirektiivit
OpenMP-ohjelmointi perustuu ensisijaisesti kntjdirektiivien kyttn.
Lhdekoodissa merkitn rinnakkaisesti suoritettavat osat ja annetaan rinnakkaistamiseen liittyvi ohjeita. Rinnakkainen osa voi olla silmukkarakenne, jonka suoritus jaetaan eri prosessoreiden kesken, tai joukko erillisi ohjelmalohkoja. OpenMP:ll on siis suhteellisen helppo tehd rinnakkaistettu
versio vanhasta perkkiskoodista.
OpenMP-direktiivit kirjoitetaan kommenttirivein. Rinnakkaistettavat alueet
merkitn direktiiveill
!$OMP PARALLEL mreet
ohjelmalohko
!$OMP END PARALLEL
Ellei toisin mritell, alueen lopussa sikeet jvt odottamaan muita sikeit. Rinnakkaistettavien alueiden ulkopuolella vain yksi sie jatkaa ohjelman suoritusta. Perusmreit rinnakkaistettaville alueille ovat mm. PRIVATE
ja SHARED, joilla annetaan lista yksityisist ja yhteisist muuttujista, sek
REDUCTION, jolla mritelln reduktio-operaatio ja -muuttuja.
Tynjakoa stelevist rakenteista trkein on
!$OMP DO mreet
DO-silmukka
!$OMP END DO
Tll mritelln rinnakkaistettava silmukka. Lisksi erillisi ohjelmalohkoja voidaan luetella !$OMP SECTIONS -rakenteella.
307
Sikeiden suoritusta voidaan mys synkronoida joukolla direktiivej. Nist

yksinkertaisin on !$OMP BARRIER, joka pysytt kaikki sikeet odottamaan
viimeist.
17.3.2 OpenMP-esimerkki
Kytmme esimerkkin kappaleessa 3.16 (sivu 38) esitelty simulointitehtv, jossa yksikknelin sijoitetaan pistepareja ja lasketaan niiden etisyyden keskiarvo.
Alkuperiseen perkkiskoodiin ei tehd muita muutoksia kuin kommentteina nkyvt !$OMP-direktiivit. Edell esitetyt !$OMP PARALLEL ja !$OMP
DO -direktiivit on yhdistetty !$OMP PARALLEL DO -direktiiviksi OpenMP:n
yksittiselle silmukalle salliman syntaksin mukaisesti. Lisksi kytmme direktiivin jatkorivimerkint.
PROGRAM points
IMPLICIT NONE
REAL(KIND=prec), DIMENSION(2) :: a, b
REAL(KIND=prec) :: d, s = 0.0_prec
INTEGER :: i
WRITE (*,*) Number of pairs:, n
!$OMP PARALLEL DO PRIVATE(a,b,i) &
!$OMP REDUCTION(+:s)
DO i = 1, n
s = s + SQRT(SUM((a - b)**2))
END DO
!$OMP END PARALLEL DO
d = s/n
WRITE (*,*) Mean distance:, d
END PROGRAM points
Rinnakkaistettava silmukka jaetaan ohjelman suoritusvaiheessa mritellylle lukumrlle prosessoreita. Silmukan indeksien jakotapa prosessoreiden
kesken voidaan mritell. Yll nin ei ole tehty, jolloin jako on kntjriippuvainen.
Muuttujat a, b ja i ovat yksityisi, eli kullakin prosessorilla tai sikeell on
oma kopionsa nist. Muuttuja s on mritelty reduktiomuuttujaksi. Tllin
kullakin sikeell on oma kopionsa kyseisest muuttujasta, kunnes rinnakkaisen osan lopussa paikalliset muuttujat yhdistetn reduktio-operaatiolla.
Esimerkiss reduktio-operaatio on +, jolloin paikalliset summat lasketaan
lopuksi yhteen, kuten alkuperisess perkkiskoodissa. Oletusarvoisesti
muuttujat ovat yhteisi, kuten tss n.
308
Fortran 95/2003
Ohjelma knnetn ja suoritetaan CSC:n Cedar-koneessa seuraavasti

% f90 -o example example.f90 -mp
% ./example -np 4
Valitsin -np mr suorittavien prosessorien lukumrn. Periaatteessa lukumr voidaan mritell mys dynaamisesti lhdekoodin sisll kullekin
rinnakkaistettavalle alueelle.
Huomaa, ett HPF:st puuttuva reduktiorakenne olisi estnyt esimerkkimme silmukan rinnakkaistuksen, koska silmukka ei olisi ollut muodollisesti
riippumaton. Vaikka summaus onkin todellisuudessa jrjestyksest riippumaton, HPF:n syntaksi kielt direktiivin !HPF$ INDEPENDENT kytn.
MPI:ll ohjelmoijan olisi puolestaan pitnyt huolehtia eksplisiittisesti viestinvlityksest ja tynjaosta.
17.3.3 Muita piirteit ja listietoja OpenMP:st

OpenMP:ss on mritelty mys kirjastorutiineja ja ympristmuuttujia.
Nill voidaan mm. st sikeiden dynaamista ja siskkist luontia.
OpenMP:n kotisivut lytyvt www-osoitteesta
http://www.openmp.org/
Nilt www-sivuilta voi hakea OpenMP:n mrittelyt Fortranille ja C/C++:lle.
Harjoitustehtvi
1. Rinnakkaista kappaleessa 3.16 sivulla 38 esitelty pisteparit-simulointiohjelma kytten HPF:.
2. Kirjoita kappaleessa 14.4 sivulla 247 esitellyst yksiulotteisesta soluautomaatista HPF:ll rinnakkaistettu versio.
3. Kirjoita kappaleessa 14.5 sivulla 253 esitellyst Life-pelist HPF:ll rinnakkaistettu versio.
4. Kirjoita kappaleessa 14.8 sivulla 263 esitellyst dierentiaalievoluutioalgoritmista HPF:ll rinnakkaistettu versio.
5. Kirjoita kappaleessa 14.9 sivulla 269 esitellyst liittogradienttialgoritmista HPF:ll rinnakkaistettu versio.
6. Tutki Poissonin menetelmn ajoajan kyttytymist, kun prosessorien
mr on esimerkiksi 4, 8, 16 tai 32. Ent miten mallikoko vaikuttaa
laskenta-ajan kyttytymiseen?
7. Toteuta tehtvt 16 kytten OpenMP:t.
Liite
310
Fortran 95/2003
Ohjelmoinnin kultaiset
snnt
Seuraavat ohjeet on tarkoitettu muistilistaksi virheiden vlttmiseksi ja turhan ohjelmointityn minimoimiseksi.
A.1 Yleisohjeita
Kun ohjelmakoodi on sinulle itsellesi selkesti luettavaa, ymmrrettv
ja helposti yllpidettv, on se mys kntjlle helppoa ksitell.
Kirjoita jsennetty, selke ja luettavaa ohjelmakoodia. Ohjelmasi seuraava tulkitsija ja lukija olet mit todennkisemmin sin itse muutaman unohduskuukauden jlkeen.
Sano se mit haluat yksinkertaisesti, suoraan ja selkesti; vlt kikkoja.
Anna ohjelman ja tietokoneen tehd likainen ty. Kyt valmiita aliohjelmakirjastoja, l keksi pyr uudestaan.
A.2 Ohjausrakenteet
Vlt sotkuista ohjelmalogiikkaa. Kyt Fortran 95:n kehittyneit ohjausrakenteita harkiten!
Vlt huonoja ja vanhentuvia Fortranin rakenteita. Useimmat nist rakenteista ovat mys koodin optimoinnin esteit. Kyt sen sijaan kielen
hyvi piirteit, kuten ohjausrakenteita
IF . . .
THEN . . .
ELSE . . .
END IF
SELECT CASE . . .
CASE . . .
END SELECT
DO . . .
END DO
DO WHILE . . .
END DO
l numeroi mitn muita lauseita kuin mahdolliset FORMAT-lauseet sek I/O-rutiinien virheenksittelyyn liittyvt lauseet. Ohjelmasi luettavuus paranee.
A. Ohjelmoinnin kultaiset snnt
311
A.3 Mrittele
Mrittele kaikki kyttmsi muuttujat. Kyt lausetta IMPLICIT NONE,
jolloin mahdolliset kirjoitus- ja tyyppivirheet paljastuvat yleens jo
knnsaikana.
Mrittele kyttmsi proseduurit moduuleissa jos mahdollista, tai kyt INTERFACE-rakennetta. Nin saat kyttsi tehokkaan knnsaikaisen virheentarkistuksen.
Mrittele ohjelmassa esiintyville vakioille (esimerkiksi taulukoiden dimensioiden koot) symboliset nimet PARAMETER-mreill. Nin kannattaa tehd vhintnkin silloin, kun vakio esiintyy useassa kohdassa ohjelmaa.
Kyt yhdenmukaisia tyyppimrittelyj, esimerkiksi:
IMPLICIT NONE
INTEGER, PARAMETER :: short = SELECTED_REAL_KIND(6,30)
REAL (KIND=short) :: a
REAL (KIND=short), DIMENSION(100) :: b
A.4 Strukturoi
Koeta erist asiat tehtvsi kannalta loogisiksi ja samalla riittvn pieniksi kokonaisuuksiksi. Ohjelmoi sitten nm kokonaisuudet moduuleihin sijoitetuiksi proseduureiksi. Toisin sanoen: tee ohjelmistasi modulaarisia. Anna tehtvsi mrt ohjelman rakenne.
Jokaisen proseduurin tulee tehd yksi ja vain yksi asia ja tehd se hyvin.
Jokaisen proseduurin tulee piilottaa ohjelman jonkin yksityiskohdan
toteutustekniikka kutsuvilta ohjelmilta. Tee kunkin proseduurin liittymt muihin ohjelmiin mahdollisimman selkeiksi. Toisaalta: l tee turhia rajoituksia proseduuriesi yleisyyden suhteen, jos mahdollista.
A.5 Standardoi
Kirjoita standardia, luettavaa, muutettavaa ja siirrettv ohjelmateksti. Pyri eristmn kone- ja kntjriippuvat asiat omiin, helposti
lydettviin ja muutettaviin paikkoihin, jos niit ylipns tarvitset, ja
dokumentoi ne. l paikkaa huonoa koodia, vaan kirjoita se uusiksi.
A.6 Dokumentointi
Dokumentoi ohjelmasi kunnolla, mys sen kyttm data ja tiedostot.
312
Fortran 95/2003
Kommentoi ohjelmaasi. Hyv kommentti harvoin vain toistaa sanoin

sen mit Fortraniksi on kirjoitettu, vaan selitt miksi niin tehdn. l
kommentoi huonoja ratkaisuja, vaan kirjoita ohjelma paremmin. Kommentoi erityisen tarkkaan laite- ja kntjriippuvuudet, poikkeamat
standardeista ja poikkeaman syyt, ja muut erikoiset ja eptavalliset ratkaisut. l kommentoi trivialiteetteja.
A.7 Luettavuus
l kirjoita ptkspagettia. Kirjoita selkesti, kyt mielekkit nimi,
sisenn ohjelmateksti oikein. Kirjoita ohjelmat siten, ett ne etenevt ylhlt alaspin oikeassa jrjestyksess. Voit jopa kirjoittaa ne ensin jrkevll pseudo-Fortranilla ja knt ne sitten standardi-Fortraniksi.
Kyt selkeit ja mielekkit muuttujien nimi. Fortran 90 -standardi
rajoittaa nimen pituuden korkeintaan 31 merkkiin.
l kyt sarkain- eli tabulaattorimerkkej. Toisaalta voit kytt pieni kirjaimia koodin selkeyden parantamiseksi. Skandinaavisia merkkej (, jne.) ei voi kuitenkaan kytt muuten kuin kommenteissa tai
merkkijonoissa.
Ohjelmakoodin kirjoittamista ja editointia helpottaa Fortran 95
-kielen syntaksia ymmrtv editori, esimerkiksi Emacs, jolla voi mys
muotoilla koodia luettavampaan muotoon.
A.8 Vianetsint ja koodin testaus

Kiinnit huomiota ohjelmasi testaamiseen. Muodosta kattava joukko
testej ohjelmasi eri osa-alueille. Testaa eri ohjelmayksikt mys erikseen.
Kun list ohjelmaasi uusia piirteit, testaa nit piirteit uusilla testeill, mutta l unohda aikaisempia testej.
l pyshdy yhteen lytmsi virheeseen. l luovuta ennen kuin olet
testannut ohjelman perusteellisesti.
Testaa rajatapaukset. Varo taulukkojen indeksien ylityksi ja laskureiden yhdell pieless tilanteita. Tarkkaile muuttujien arvojen erikoistapauksia ja muita erikoistilanteita, jotka usein ovat virheiden syin.
Varmistu erityisesti siit, ett ohjelmasi toimii oikein niiss erikoistilanteissa, joissa sen ei tule tehd mitn.
Varo alustamattomia muuttujia. Alusta kaikki muuttujat, lk luota
siihen, ett ne ovat nollia automaattisesti. Alustuksen voi usein tehd
muuttujan mrittelyn yhteydess tai ohjelmayksikss suoritettavalla
lauseella:
A. Ohjelmoinnin kultaiset snnt
313
IMPLICIT NONE
INTEGER, PARAMETER :: short = SELECTED_REAL_KIND(6,30)
REAL (KIND=short) :: a = 0, t = -1, u
REAL (KIND=short), DIMENSION(100) :: b = 1
...
u = SIN(t + a)
...
Varo pyristysvirheit: 10.0 0.1 on tuskin koskaan 1.0! l vertaa liukulukujen (reaalilukujen) yhtsuuruutta. Kyt numeerisesti luotettavia algoritmeja (tm ei ole triviaali asia!). Kyt apuna asiantuntijoita
ja tunnettuja aliohjelmakirjastoja!
A.9 Ohjelmakoodin optimointi

Aluksi ohjelman kirjoituksen pmrn tulee olla pelkstn oikein
toimivan ohjelman kirjoittaminen. Harkitse kuitenkin kyttmsi algoritmia heti tarkkaan. Usein huomattavasti tehokkaampaa ohjelmaa saa
kyttmll tehokkaampaa algoritmia, ei optimoimalla koodia.
l optimoi ohjelmakoodia liian aikaisin. Kun alat muokata koodia tehokkaammaksi, mittaa ensin, miss ohjelmasi kuluttaa aikaansa. Muokkaa sitten sit vaikkapa 10 %:n aluetta, jossa kuluu noin 90 % ohjelman
ajoajasta. Nin hydyt nopeimmin ja eniten. Kun muokkaat koodia, ohjelmasi pit tietysti pysy oikein toimivana. l koskaan uhraa selkeytt pieniin tehokkuusetuihin.
Siis: ensin oikein, sitten tehokkaammin (ja edelleen oikein)!
A.10 Sytt ja tulostus

Testaa syttarvojen jrkevyys. Tunnista jrjettmt syttarvot, ja toivu tilanteesta jos mahdollista. Testaa erityisesti (odottamattomat) tiedostojen loput.
Tee sytt mahdollisimman yksinkertaiseksi ja helpoksi. Vapaamuotoinen sytt on jrkev pieni kontrolliarvoja varten. Vain suuret dataaineistot kannattaa lukea mrmuotoisena. Tulostus sen sijaan kannattaa useimmiten tehd mrmuotoisesti. Tee syttaineisto helpoksi lukea.
Sijoita sytt ja tulostus selkeisiin proseduureihin. l sirottele tulostuslauseita joka paikkaan (ne estvt koodin optimoinnin).
Kyt syttarvoille oletuksia jos mahdollista. Kaiuta sytetyt arvot tulostukseen tai erityiseen lokitiedostoon.
314
Fortran 95/2003
Vlt mys FORMAT-lauseita ja niiden numerointia. Vain kerran tai kahdesti kytettvn FORMAT-lauseenkin voi sijoittaa nimettyn merkkijonovakiona suoraan sit kyttvn WRITE- tai READ-lauseeseen, jolloin
kyseinen I/O-lause ja sit vastaava formaatti ovat samassa paikassa helposti lydettviss.
Tarkkaile syttja tulostustoimintoja. Tm voi usein olla tehottomin
osa ohjelmaasi. Kyt jrkevi ja tehokkaita I/O-menetelmi. Suunnittele sytt ja tulostus huolella.
Jos luet tai tulostat suuria datamri, saat ohjelmastasi tehokkaamman
kyttmll binrist sytt ja tulostusta.
A.11 Yhteenveto
Trkeimpn kaikista ohjeista:
Harkitse kyttmsi algoritmi tarkkaan!
Aiheesta lytyy lis luettavaa mm. seuraavasta hauskasta ja hydyllisest
kirjasesta: The Elements of Programming Style [KP78].
B. Fortran 95:n hyvt, pahat ja rumat piirteet
315
Fortran 95:n hyvt, pahat

ja rumat piirteet
Esitmme seuraavassa CSC:n kokemuksia Fortran 95:st. Tyyliseikoista ei

kannata tietenkn kiistell, mutta ohjelmoinnissa on syyt olla selke tyyli,
jotta vltytn vrinksityksilt.
B.1 Hyvt piirteet

Lause IMPLICIT NONE poistaa kytst alkukirjainsnnn.
Uuden tyyppiset muuttujamrittelyt tyyliin
REAL, PARAMETER :: ...
selkeyttvt koodia.
Lajiparametrit (kind) parantavat koodien siirrettvyytt.
Fortran 95:n ohjausrakenteet helpottavat ohjelmointia.
Lhdekoodin vapaa syttmuoto parantaa luettavuutta.
Moduulit tekevt ohjelmoinnista luotettavampaa ja tehokkaampaa (esimerkiksi proseduurien argumenttilistojen knnsaikainen tarkistus).
Dynaaminen muistinvaraus helpottaa ohjelmointityt.
Proseduurien argumenttien INTENT-mreet parantavat knnsaikaisia tarkistuksia.
Uudet operaattorimerkinnt (<, >, <=, >=, == ja /=) parantavat koodin
luettavuutta.
Taulukkosyntaksi helpottaa ja tehostaa koodaamista sek parantaa koodin luettavuutta.
316
Fortran 95/2003
B.2 Toisinaan hydylliset piirteet

Rakenteiset muuttujatyypit mahdollistavat monimutkaisten tietorakenteiden luomisen (esimerkiksi listat).
Osoitinmuuttujat mahdollistavat dynaamisen tavan viitata muuttujiin
tai esimerkiksi taulukkojen osiin.
Sisiset proseduurit ovat ktevi pienten apurutiinien mrittelyss.
Valinnaiset argumentit mahdollistavat proseduurikutsut, joissa tarvitsee antaa vain osa argumenteista muille kytetn oletusarvoja.
Avainsana-argumentit voivat selkeytt proseduurien argumenttien merkityst.
Geneeriset proseduurit mahdollistavat saman nkisen proseduurikutsun eri tyyppisille argumenteille, mutta voivat mys tehd koodista vaikeammin ymmrrettv.
NAMELIST-tiedonsiirto on ktev esimerkiksi ohjelman sytttietojen
antamisessa, mutta sit ei kannata kytt suurille tietomrille.
Mreill PUBLIC ja PRIVATE voi sdell moduulissa mriteltyjen olioiden nkyvyytt moduulin ulkopuolelle.
Ohjausrakenne DO WHILE on ktev joissakin tilanteissa. Vertaa seuraavia ekvivalentteja ohjausrakenteita:
DO WHILE (ehtolauseke)
...
END DO
DO
IF (.NOT. ehtolauseke) EXIT
...
END DO
B.3 Mahdollisesti vaaralliset piirteet

Omien operaattorien mrittely voi tehd koodista hyvin vaikeasti ymmrrettv ja tehotonta.
Vanhan FORTRAN 77:n piirteet kuten COMMON, EQUIVALENCE, GOTO jne.
tekevt koodista vaikeasti siirrettv ja hankalasti luettavaa.
Antiikkinen sarakesidonnainen lhdekoodin muoto tekee ohjelmista vaikeasti luettavia.
C. Yhteenveto Fortran 95 -kielen lauseista
317
Yhteenveto Fortran 95
-kielen lauseista
Luettelemme tss liitteess trkeimmt Fortran 95 -kielen lauseet. Kielen

syntaksia ei ole kuvattu tydellisen, vaan sen sijaan esitmme lauseiden
tyypilliset kytttavat.
Merkinttavat
Esitmme Fortran 95 -kielen omat tunnukset isoilla kirjaimilla, esimerkiksi
PROGRAM tunnus
Kyttjn mriteltviss olevat tunnukset on esitetty vinokirjaimilla kuten

edell. Jos lauseen osa ei ole vlttmtn, on kytetty hakasulkuja merkitsemn tllainen kohta. Kolmella pisteell ... merkitn nolla tai useampi
kertaa toistettavissa olevaa lauseen osaa:
CALL-lauseen vaihtoehtoisia muotoja ovat siis esimerkiksi:

CALL
CALL
CALL
CALL
aliohjelma
aliohjelma(arg1)
aliohjelma(arg1, arg2)
aliohjelma(arg2=arvo, arg1=arvo)
Viimeisess kutsussa kytettiin avainsana-argumentteja.
Yhteenveto Fortran 95:n lauseista

Ohjelmayksikiden mrittely:
[PROGRAM tunnus]
[mrittelylauseet]
[CONTAINS
sisinen_proseduuri
318
Fortran 95/2003
END [PROGRAM [tunnus]]
[RECURSIVE] SUBROUTINE tunnus[([argumentti][, argumentti]...])]
[mrittelylauseet]
[CONTAINS
sisinen_proseduuri
END [SUBROUTINE [tunnus]]
[tyyppi] [RECURSIVE] [tyyppi] FUNCTION tunnus([argumentti] &
[, argumentti]...) [RESULT(tunnus)]
[mrittelylauseet]
[CONTAINS
sisinen_proseduuri
END [FUNCTION [tunnus]]
MODULE tunnus
[mrittelylauseet]
[CONTAINS
moduulin_proseduuri
[moduulin_proseduuri]...]
END [MODULE [tunnus]]
BLOCK DATA [tunnus]
[mrittelylauseet]
END [BLOCK DATA [tunnus]]
Tiedoston sisllyttminen osaksi koodia:

INCLUDE merkkijonovakio
Alkukirjainsnnn kumoaminen:
IMPLICIT NONE
Alkukirjainsnnn asettaminen:
IMPLICIT tyyppi (kirjainmrittely[, kirjainmrittely]...)
Muuttujien tyypin mrittely:

tyyppi[[, mre]... ::] tunnus[, tunnus]...
Esimerkkej muuttujien mrittelyst:

REAL [([KIND=]lajiparametri)]
COMPLEX [([KIND=]lajiparametri)]
INTEGER [([KIND=]lajiparametri)]
CHARACTER [([LEN=]arvo)]
CHARACTER ([LEN=]arvo[, [KIND=]lajiparametri])
CHARACTER (KIND=lajiparametri[, LEN=arvo])
CHARACTER*pituus
LOGICAL [([KIND=]lajiparametri)]
DOUBLE PRECISION
TYPE (tunnus)
Tyyppimrittelyn mreit (attribuutteja):

ALLOCATABLE
DIMENSION (ulottuvuudet)
EXTERNAL
INTENT (inout_mre)
INTRINSIC
OPTIONAL
PARAMETER
POINTER
PRIVATE
PUBLIC
SAVE
TARGET
Erillisi mrittelylauseita:
ALLOCATABLE [::] taulukko_lista
COMMON [/ tunnus /] lista_olioita
DATA lista_olioista / lista_arvoja /
DIMENSION taulukon_dimensiomrittely
EQUIVALENCE lista
IMPLICIT mrittely
NAMELIST /namelist_ryhmn_nimi/ lista_jsenist
POINTER [::] taulukko_lista
TARGET [::] taulukko_lista
Taulukkojen mrittely:
tyyppi, DIMENSION(arvo[, arvo]...) :: tunnus[, tunnus]...
tyyppi[[, mre]... ::] tunnus(arvo[, arvo]...)
tyyppi, DIMENSION(arvo[, arvo]...), ALLOCATABLE :: &
tunnus[, tunnus]...
tyyppi, DIMENSION(arvo[, arvo]...), TARGET :: &
tunnus[, tunnus]...
tyyppi, DIMENSION(arvo[, arvo]...), POINTER :: &
tunnus[, tunnus]...
Nimetyt vakiot:
tyyppi, PARAMETER :: tunnus[, tunnus]...
PARAMETER ( mrittelylista )
Rakenteisten tyyppien mrittely:

TYPE[, julkisuusmre [::]] tunnus
[PRIVATE]
[SEQUENCE]
[tyyppi[[, mre] ::] komponentit...]...
END TYPE [tunnus]
319
320
Fortran 95/2003
Proseduurien mrittelylauseet:
EXTERNAL [::] tunnus[, tunnus]...
INTRINSIC [::] tunnus[, tunnus]...
Proseduurien argumenttien mreet:

muuttujamrittely, INTENT(IN) :: tunnus[, tunnus]...
muuttujamrittely, INTENT(OUT) :: tunnus[, tunnus]...
muuttujamrittely, INTENT(INOUT) :: tunnus[, tunnus]...
muuttujamrittely, INTENT(IN OUT) :: tunnus[, tunnus]...
INTENT(inout_mre) [::] tunnus[, tunnus]...
mrittely, OPTIONAL :: tunnus[, tunnus]...
mrittely, SAVE :: tunnus[, tunnus]...
OPTIONAL [::] lista
SAVE [[::] lista]
Moduulin kyttminen:
USE moduuli[, paikallinen_nimi => nimi_moduulissa]...
USE moduuli, ONLY : [[paikallinen_nimi =>] nimi_moduulissa &
[, [paikallinen_nimi =>] nimi_moduulissa]...]
Moduulin olioiden julkisuus tai yksityisyys:

PUBLIC [[::] lista_moduulin_olioista]
PRIVATE [[::] lista_moduulin_olioista]
Funktion ja aliohjelman kutsu:

funktio([argumentti][, argumentti]...)
funktio([[nimi=]argumentti][, [nimi=]argumentti]...)
CALL aliohjelma[(argumentti[, argumentti]...)]
Geneeriset funktiot, aliohjelmat ja operaattorit:

INTERFACE [geneerinen_tunnus]
END INTERFACE
INTERFACE OPERATOR(operaattori)
END INTERFACE
END INTERFACE
Toistorakenteet:
[tunniste:] DO
lohko
END DO [tunniste]
[tunniste:] DO muuttuja = lauseke, lauseke[, lauseke]
lohko
END DO [tunniste]
[tunniste:] DO WHILE (ehto)
lohko
END DO [tunniste]
EXIT [tunniste]
CYCLE [tunniste]
FORALL-rakenne ja -lause:
[tunniste:] FORALL (kolmikko[, kolmikko]...[, maski])
lohko
END FORALL [tunniste]
FORALL (kolmikko[, kolmikko]...[, maski]) muuttuja = lauseke
FORALL (kolmikko[, kolmikko]...[, maski]) osoitin => kohde
Tss kolmikko on muotoa

indeksimuuttuja = alku:loppu[:askel]
Ehtorakenteet:
[tunniste:] IF (ehto) THEN
lohko
[ELSE IF (ehto) THEN [tunniste]
lohko]
[ELSE [tunniste]
lohko]
END IF [tunniste]
IF (ehto) lause
IF (numeerinen_lauseke) lausenro, lausenro, lausenro
Tapausrakenne:
[tunniste:] SELECT CASE (lauseke)
[CASE (arvo[, arvo]...) [tunniste]
lohko]...
[CASE DEFAULT [tunniste]
lohko]
END SELECT [tunniste]
WHERE-rakenne:
WHERE (ehto) muuttuja = arvo
321
322
Fortran 95/2003
WHERE (ehto)
[sijoituslause]...
[ELSEWHERE
[sijoituslause]...]
END WHERE
Hyppylause:
GO[ ]TO lausenumero
GO[ ]TO (lausenumero_lista) kokonaislukulauseke
GO[ ]TO kokonaislukumuuttuja[[,] (lausenumero_lista)]
[lausenumero] CONTINUE
Suoritettavia lauseita:
ALLOCATE (lista[, STAT=kokonaislukumuuttuja])
DEALLOCATE (lista[, STAT=kokonaislukumuuttuja])
NULLIFY (osoitinmuuttuja_lista)
ASSIGN lausenumero TO kokonaislukumuuttuja
Sijoituslauseet:
muuttuja = lauseke
osoitinmuuttuja => kohde
Ohjelman suorituksen lopettaminen tai keskeytys:

STOP [merkkijono]
STOP [koodi]
PAUSE [koodi]
Paluu proseduurista kutsuvaan ohjelmayksikkn:

RETURN
Tiedostojen ksittely:
OPEN ([UNIT=]kanava[, FILE=lauseke][,STATUS=lauseke] &
[, ACCESS=lauseke][, RECL=lauseke][, FORM=lauseke] &
[, BLANK=lauseke][, ERR=lausenumero][, IOSTAT=muuttuja])
CLOSE ([UNIT=]kanava[, STATUS=lauseke][, ERR=lausenumero] &
[, IOSTAT=muuttuja])
INQUIRE (FILE=tiedoston_nimi, argumenttilista)
INQUIRE (UNIT=kanava, argumenttilista)
BACKSPACE kanava
BACKSPACE ([UNIT=]kanava[, IOSTAT=iostat][, ERR=err-lause])
REWIND kanava
REWIND ([UNIT=]kanava[, ERR=lausenumero][, IOSTAT=muuttuja])
ENDFILE kanava
ENDFILE ([UNIT=]kanava[, ERR=lausenumero][, IOSTAT=muuttuja])
Tiedon sytt:
READ muotoilukoodi, muuttujalista
READ *, muuttujalista
READ
[,
READ
[,
READ
[,
READ
[,
READ
[,
READ
[,
READ
[,
([UNIT=]kanava, [FMT=]muotoilukoodi[, END=lauseke] &

ERR=lauseke][, IOSTAT=lauseke]) muuttujalista
([UNIT=]kanava, [FMT=]*[, END=lauseke] &
([UNIT=]*, [FMT=]muotoilukoodi[, END=lauseke] &
([UNIT=]*, [FMT=]*[, END=lauseke] &
([UNIT=]kanava[, END=lauseke] &
([UNIT=]kanava, [FMT=]muotoilukoodi, REC=lauseke &
([UNIT=]kanava, REC=lauseke &
Tiedon tulostaminen:
PRINT *, tulostuslista
PRINT muotoilukoodi, tulostuslista
WRITE ([UNIT=]kanava, [FMT=]muotoilukoodi[, ERR=lauseke] &
[, IOSTAT=lauseke]) tulostuslista
WRITE ([UNIT=]kanava, [FMT=]*[, ERR=lauseke] &
WRITE ([UNIT=]*, [FMT=]muotoilukoodi[, ERR=lauseke] &
WRITE ([UNIT=]*, [FMT=]*[, ERR=lauseke] &
WRITE ([UNIT=]kanava[, ERR=lauseke] &
WRITE ([UNIT=]kanava, [FMT=]muotoilukoodi, REC=lauseke &
[, ERR=lauseke][, IOSTAT=lauseke]) tulostuslista
WRITE ([UNIT=]kanava, REC=lauseke[, ERR=lauseke] &
Muotoilukoodin mrittely:
lausenumero FORMAT (muotoilukoodi)
323
324
Fortran 95/2003
ASCII-merkist
ASCII (American Standard Code for Information Interchange) on 7-bittinen

standardi merkkimuotoisen tiedon esittmiseen tietokoneessa. Seuraavassa taulukossa on esitetty ASCII-merkkej vastaavat desimaalikoodit. Kunkin
merkin koodi saadaan laskemalla yhteen rivin ja sarakkeen tunnukset. Esimerkiksi W-kirjaimen ASCII-koodi on 87.
0
10
20
30
40
50
60
70
80
90
100
110
120
^@
^J
^T
RS
(
2
<
F
P
Z
d
n
x
Â
^K
Û
US
)
3
=
G
Q
[
e
o
y
^B
^L
^V
^C
^M
^W
!
+
5
?
I
S
]
g
q
{
^D
^N
^X
"
,
6
@
J
T
^
h
r
|
Ê
Ô
^Y
#
7
A
K
U
_
i
s
}
^F
^P
^Z
$
.
8
B
L
V
j
t
^G
^Q
ESC
%
/
9
C
M
W
a
k
u
DEL
^H
^R
FS
&
0
:
D
N
X
b
l
v
Î
^S
GS
1
;
E
O
Y
c
m
w
*
4
>
H
R
\
f
p
z
E. Sanasto
325
Sanasto
actual argument: todellinen

argumentti
allocatable array: dynaaminen
taulukko
allocate: varata tilaa
allocation statement: tilanvarauslause
allocation status: varaustilanne
alternate return: vaihtoehtoinen
paluukohta
argument: argumentti
arithmetic if statement: aritmeettinen
ehtolause
array: taulukko
array assignment: taulukkojen
sijoituslause
array constructor: taulukon rakennin,
taulukon alustin, taulukon
muodostin
array element: taulukon alkio
array element order: taulukon
alkiojrjestys
array expression: taulukkkolauseke
array pointer: taulukko-osoitin
array section: taulukon lohko
array specication: taulukon
mrittely
array-valued object: taulukkoarvoinen
olio
assigned goto: epsuora hyppyksky
assignment: sijoitus
assignment statement: sijoituslause
associated pointer: muuttujaan liittyv
osoitin
assumed character length: oletetun
mittainen merkkijono
assumed-shape array: oletetun
muotoinen taulukko
assumed-size array: oletetun kokoinen
taulukko
attribute: mre
automatic array: automaattinen
taulukko
automatic object: automaattinen olio

binary operator: kaksiargumenttinen
operaattori
bit: bitti
blank: vlilyntimerkki
block: lohko
bound: (arvoalueen) raja
byte: tavu
call: kutsua, kutsu
case: tapaus
case construct: tapausrakenne
character: merkki
character data: merkkitieto
character string: merkkijono
coercion: muunnos vahvempaan
tyyppiin
collating sequence: merkkijrjestys,
merkkidatan lajittelujrjestys
comment: kommentti
common block: common-alue
comparison operator:
vertailuoperaattori
compiler: kntj
complex number: kompleksiluku
component: rakenteisen tyypin alkio
component selector: alkion valitsin (%)
computed goto: haarautuva
hyppyksky
concatenation operator:
liitosoperaattori (//)
conformable arrays: samanmuotoiset
taulukot
constant: vakio
construct: rakenne
constructor: rakennin, alustin,
muodostin
continuation line: jatkorivi
control statement: ohjauslause
data type: tietotyyppi
data parallel: datarinnakkainen
deallocate: vapauttaa tilaa
declaration: esittely
326
default kind: oletuslaji

deferred-shape array: myhemmin
varattava taulukko
dened assignment: kyttjn
mrittelem sijoituslause
dened operator: kyttjn
mrittelem operaattori
dened variable: alustettu muuttuja
denition: mrittely
denition of a type: tyypin mrittely
deleted feature: poistettu piirre
derived type, derived data type:
rakenteinen datatyyppi
designator: alkion valitsin
design pattern: suunnittelumalli
digit: numeromerkki
dimension: ulottuvuus
direct access: suorasaanti
directive: direktiivi
disassociated pointer: kohteesta
irrotettu osoitin
dummy argument: muodollinen
argumentti
dummy array: muodollinen
taulukkoargumentti
dummy pointer: muodollinen
osoitinargumentti
dyadic (binary) operator:
kaksiargumenttinen operaattori
edit descriptor: muotoilukoodi
element: alkio
elemental: alkioittainen
elemental intrinsic procedure:
alkioittainen standardiproseduuri
executable program:
suorituskelpoinen ohjelma
executable statement: suoritettava
lause
explicit interface: tunnettu
kutsumuoto
explicit-shape array: tunnetun
muotoinen taulukko
expression: lauseke
extension: laajennus
extended type: laajennettu tyyppi
extent: (taulukon ulottuvuuden) koko
external: ulkoinen
external procedure: ulkoinen
proseduuri
le: tiedosto
nalizer: lopettaja
xed source form: sarakesidonnainen
lhdekoodin muoto
oating point number: liukuluku,
reaaliluku
Fortran 95/2003
format: tiedon esitysasu, muotoilu

format specier: muotoilukoodi
free source form: vapaa lhdekoodin
muoto
function: funktio
generic interface: geneerinen
kutsumuoto
generic procedure: geneerinen
proseduuri
global entity: globaali tunnus
goto statement: hyppylause
host: isnt
host association: viittaus isnnn
mrittelemiin olioihin
host scoping unit: isnnn
nkyvyysalue
implicit declaration:
alkukirjainsntn perustuva
tyyppimrittely
implicit interface: oletusarvoinen
kutsumuoto
implied DO list: toistolista
index: indeksi
inheritance: periytyminen
input: syte, sytt
inquiry function: kyselyfunktio
integer: kokonaisluku
intent: proseduurin argumentin
tiedonsiirron suunta
interface block: kutsumuodon
mrittelylohko
internal le: sisinen tiedosto
internal procedure: sisinen
proseduuri
intrinsic data type: standardityyppi,
sisinen tietotyyppi
intrinsic function: standardifunktio
intrinsic operator:
standardioperaattori
intrinsic procedure:
standardiproseduuri
intrinsic subroutine:
standardialiohjelma
keyword argument:
avainsana-argumentti
kind: laji
kind type parameter: lajiparametri
label: lausenumero
lexical token: (ohjelmointikielen)
perusalkio
list-directed formatting: listan ohjaama
muotoilu
literal constant: (nimetn) vakio
local: paikallinen
local entity: paikallinen olio
E. Sanasto
logical operator: looginen operaattori

logical value: looginen arvo
loop: silmukka
lower bound: alaraja
main program: pohjelma
mask: peite
message-passing: vistinvlitys
mixed-mode expression: eri tyyppej
sisltv lauseke
module: moduuli
module procedure: moduulin
proseduuri
monadic (unary) operator:
yksiargumenttinen operaattori
named constant: nimetty vakio
named object: nimetty olio
non-advancing input/output: osittaista
tietuetta ksittelev sytt tai
tulostus
numeric expression: numeerinen
lauseke
numeric type: kompleksiluku,
kokonaisluku tai reaalilukutyyppi
object: olio
object-oriented programming:
olio-ohjelmointi
obsolescent feature: vanhentuva piirre
operand: operandi
operator: operaattori
optional argument: valinnainen
argumentti
output: tuloste, tulostaa
output list: tulostettava tieto
overloading: ylilataus
parameter: (nimetty) vakio
parameter attribute: vakiomre
preconnected: valmiiksi mritellyt
kanavanumerot (5, 6 ja 7)
pointer: osoitin
pointer array: osoitintaulukko
pointer assignment: osoitinten
sijoituslause (=>)
pointer association: osoittimen
kohdistaminen dataan
polymorphism: monimuotoisuus,
polymorsmi
private: yksityinen
procedure: proseduuri (funktio tai
aliohjelma)
procedure interface: proseduurin
kutsumuoto
program: ohjelma
program unit: ohjelmayksikk
public: julkinen
pure: sivuvaikutukseton (proseduuri
327
tms.)
quote: heittomerkki
range: vaihteluvli
rank: ulottuvuuksien lukumr
real number: reaaliluku
record: tietue, jono arvoja joita
ksitelln yhten kokonaisuutena
tiedostossa
recursive: rekursiivinen
relational operator: vertailuoperaattori
reshape: muokata
return: paluu proseduurista,
rivinvaihto
return value: funktion palauttama
arvo
scalar variable: skalaarimuuttuja
scope, scoping unit: nkyvyysalue
selector: (tapauslauseen) valitsin
sequence: jono
sequential: perkkinen
shape: muoto
side-eect: sivuvaikutus
sign: etumerkki
size: (taulukon) koko, alkioiden
lukumr
source form: lhdekoodin syttmuoto
source program: lhdekielinen
ohjelma, lhdekoodi
specic name: erityisnimi
specication expression:
mrittelylauseke
specication statement:
mrittelylause
statement: lause
statement function: lausefunktio
statement label: lausenumero
storage association: alkioiden yhteinen
sijoittelujrjestys muistissa
stride: askelpituus
structure: rakenne
structure constructor: rakenteen
alustin
subarray: osataulukko
subexpression: osalauseke
subroutine: aliohjelma
subscript: (taulukko)indeksi
subscript triplet: taulukon lohko, joka
koostuu alkuarvosta,
loppuaskeleesta ja askeleesta
kaksoispisteell (:) erotettuna
substring: osamerkkijono,
alimerkkijono
target: kohde
transformational function:
muunnosfunktio
328
type: tyyppi
type declaration statement: tyypin
esittelylause
type parameter: tyypin parametri
unary operator: yksiargumenttinen
operaattori
undened: mrittelemtn
undened variable: mrittelemtn
muuttuja
unformatted input/output: binrinen
tiedonsiirto
Fortran 95/2003
unit: kanava
unit number: kanavanumero
upper bound: ylraja
user-dened assignment: kyttjn
mrittelem sijoituslause
user-dened operator: kyttjn
mrittelem operaattori
variable: muuttuja
variable declaration: muuttujan
esittely
vector subscript: vektori-indeksi
Kirjallisuutta
329
Kirjallisuutta
[ABM+ 92] Jeanne C. Adams, Walter S. Brainerd, Jeanne T. Martin, Brian T. Smith ja
Jerrold L. Wagener. Fortran 90 Handbook. Complete ANSI/ISO Reference.
McGraw-Hill, 1992.
[ABM+ 97] Jeanne C. Adams, Walter S. Brainerd, Jeanne T. Martin, Brian T. Smith ja
Jerrold L. Wagener. Fortran 95 Handbook. Complete ISO/ANSI Reference.
The MIT Press, 1997.
[BGA94]
Walter S. Brainerd, Charles H. Goldberg ja Jeanne C. Adams. Programmers Guide to Fortran 90. UNICOMP, 1994.
[CLR90]
Thomas H. Cormen, Charles E. Leiserson ja Ronald L. Rivest. Introduction

to Algorithms. The MIT Press, 1990.
[CS06]
Ian Chivers ja Jane Sleightholme. Introduction to Programming with

Fortran. Springer, 2006.
[EPL94]
T. M. R. Ellis, Ivor R. Philips ja Thomas M. Lahey. Fortran 90 Programming. Addison-Wesley, 1994.
[Geh96]
Wilhelm Gehrke. Fortran 95 Language Guide. Springer, 1996.
[GHJV95] Erich Gamma, Richard Helm, Ralph Johnson ja John Vlissides. Design
Patterns. Addison-Wesley, 1995.
[Haa98]
Juha Haataja, toim. Matemaattiset ohjelmistot. CSC Tieteellinen laskenta Oy, 1998. URL http://www.csc.fi/oppaat/mat.ohj/.
[Haa02]
Juha Haataja, toim. Alkurjhdyksest knnykkn nkkulmia laskennalliseen tieteeseen. CSC Tieteellinen laskenta Oy, 2002.
[Haa04]
Juha Haataja. Optimointitehtvien ratkaiseminen. CSC Tieteellinen

laskenta Oy, 2004.
[HHL+ 02] Juha Haataja, Jussi Heikonen, Yrj Leino, Jussi Rahola, Juha Ruokolainen
ja Ville Savolainen. Numeeriset menetelmt kytnnss. CSC Tieteellinen laskenta Oy, 2002.
[HJKR02] Juha Haataja, Jari Jrvinen, Jari Koponen ja Peter Rback, toim. Laskennallinen tuotekehitys: suunnittelun uusi ulottuvuus. CSC Tieteellinen
laskenta Oy, 2002.
[HJL00]
Juha Haataja, Jari Jrvinen ja Yrj Leino. Sillanrakennuksesta lkeainesuunnitteluun Matemaattinen mallintaminen suomalaisissa yliopistoissa. CSC Tieteellinen laskenta Oy, 2000. http://www.csc.fi/
raportit/mallinnus/.
[HM01]
Juha Haataja ja Kaj Mustikkamki. Rinnakkaisohjelmointi MPI:ll. CSC

Tieteellinen laskenta Oy, 2001. http://www.csc.fi/oppaat/mpi/.
[Kar01]
Hannu Karttunen. Datan ksittely. CSC Tieteellinen laskenta Oy, 2001.
330
Fortran 95/2003
[Ker93]
James F. Kerrigan. Migrating to Fortran 90. OReilly & Associates, 1993.
[KLS85]
J. Korpela, T. Larmela ja J. Salmela. FORTRAN 77. OtaDATA ry, 1985.
[KLS+ 94]
C. Koelbel, D. Loveman, R. Schreiber, G. Steele Jr. ja M. Zosel. The High

Performance Fortran Handbook. MIT Press, 1994.
[Kos97]
Kai Koskimies. Pieni oliokirja. Suomen ATK-kustannus, 1997.
[KP78]
Kernighan ja Plauger. The Elements of Programming Style. McGraw-Hill,

1978.
[MR96]
Michael Metcalf ja John Reid. The F Programming Language. Oxford

University Press, 1996.
[MRC04]
Michael Metcalf, John Reid ja Malcolm Cohen. Fortran 95/2003 Explained. Oxford University Press, 2004.
[Rei]
John Reid. The New Features of Fortran 2003. Raportti.
[RR96]
Cecil C. Rousseau ja Otto G. Ruehr, Problems and Solutions: Expected

Wire Length Between Two Randomly Chosen Terminals, Siam Review,
2/1996, Volume 38, sivut 321324. Problem 95-6 by David M. Lazo
and solution by W. Boehm.
[Saa95]
Sami Saarinen. Rinnakkaislaskennan perusteet PVM-ympristss. CSC

Tieteellinen laskenta Oy, 1995.
[Sed84]
Robert Sedgewick. Algorithms. Addison-Wesley, 1984.
Hakemisto
331
Hakemisto
Symbolit
!, 45, 46
!HPF$, 299
", 46, 53
, 46
, 53
(, 46
(/, 168, 241
), 46
*, 46, 67, 142, 143, 193, 194, 197
**, 67, 142, 143
+, 46, 67, 142, 143
,, 46
-, 46, 67, 142, 143
., 46
/, 46, 67, 142, 143
/), 168, 241
//, 53, 73, 143
/=, 77
:, 46, 164166, 179, 203, 320
::, 53, 318
;, 44, 46
<, 46, 7779
<=, 77
=, 46, 147, 320, 322
==, 7779
=>, 320, 322
>, 46, 7779
>=, 77
?, 46
$, 46
%, 46, 152
&, 36, 44, 46
_, 26
A
ABS, 222, 230
abstrakti tietorakenne, 126
ACHAR, 79, 223
ACOS, 113, 220, 230
ADJUSTL, 74, 223
ADJUSTR, 74, 223
ADVANCE=NO, 204
AIMAG, 222, 230

AINT, 222, 230
ajaminen, 128
ajokelpoinen ohjelma, 13, 26
alaviiva, 24, 26, 58
alias, 183
ALIGN, 303
alimerkkijono, 73
aliohjelma, 99, 320
kutsu, 39, 104
mrittely ja kytt, 104
rekursiivinen, 112
aliohjelmakirjasto, 19, 21, 100
alkioiden sijoittelujrjestys muistissa,
288
alkioittainen proseduuri, 115, 215
alkuarvo, 54
alkukirjainsnt, 55, 318
alkulukuteoreema, 191
alkuluvut, 182
ALL, 175, 176, 224
ALLOCATABLE, 178, 179, 189, 319
ALLOCATE, 179, 182, 189, 238, 250,
322
ALLOCATED, 175, 217
alternate return, 286
alustin
rakenteen, 153
taulukko, 168, 241
alustuslauseke, 54
.AND., 77, 78
ANINT, 222, 230
annuiteetin laskeminen, 35
ANSI-standardi, 23
ANY, 171, 175, 176, 224
argumentti, 101
avainsana-argumentti, 118, 120
muodollinen, 101, 105
proseduuri, 113
todellinen, 101, 105
valinnainen, 118, 119
argumenttilistojen tarkistus, 116
aritmeettinen IF-lause, 285
332
aritmeettiset lausekkeet, 67
array, 164
array constructor, 168
array element order, 169
ASCII-merkist, 46, 56, 79, 223, 324
ASIN, 113, 220, 230
ASSIGN, 286, 322
assigned goto, 284, 286
ASSOCIATED, 186, 217
assumed length, 285
assumed-shape array, 171
assumed-size array, 172
asteriski, 46
asuntolainan lyhennykset, 35
ATAN, 113, 220, 230
ATAN2, 70, 220, 230
automaattinen taulukko, 165
automatic array, 165
avainsana-argumentti, 118, 120
B
BACKSPACE, 204, 322
binripuu, 256
binritiedostot, 206
bisection, 135
BIT_SIZE, 226, 227
bittien ksittely, 226
BLOCK DATA, 47, 127, 281, 288, 317
bottom up, 99
BTEST, 226, 227
C
CALL, 39, 216, 317, 320
CASE, 88, 321
CASE DEFAULT, 88, 89, 321
CEILING, 71, 222
CHAR, 79, 223, 254
CHARACTER, 51, 55, 73, 318
CLASS, 297
CLASS IS, 297
CLOSE, 204, 206, 322
CMPLX, 81, 221
COMMON, 127, 278, 280, 281, 288, 319
korvaus moduuleilla, 283
compiler, 17
COMPLEX, 51, 318
computed goto, 283, 284, 288
conformable, 190
CONJG, 222, 230
conjugate gradient method, 269
CONTAINS, 31, 47, 48, 101, 108, 129,
317
CONTINUE, 95, 286, 322
COS, 220, 230
COSH, 220, 230
Fortran 95/2003
COUNT, 175, 176, 183, 224

cpu-aika, 217
CPU_TIME, 217
CSC:n yhteystiedot, 14
CSHIFT, 177, 224, 250, 255
CSIN, 230
CYCLE, 92, 321
D
DATA, 319
datarinnakkaisuus, 304
DATE_AND_TIME, 217
DBLE, 221
DE-menetelm, 263
DEALLOCATE, 179, 189, 322
debugger, 21, 192
deferred-shape array, 165
deleted feature, 284
derived type, 152
desimaaliesitys, 199
desimaalipiste, 27, 52
dierenssimenetelm, 300
dierentiaalievoluutio, 263
DIGITS, 221
DIM, 222, 230
DIMENSION, 33, 164, 189, 280, 319
disassociated, 158
DISTRIBUTE, 302, 304
DO WHILE, 9294, 321
DO-rakenne, 90, 91, 93, 321
DO-silmukka, 32
dokumentointi, 19
dollarin merkki, 46
DOT_PRODUCT, 175, 225
DOUBLE PRECISION, 60, 278, 281, 288,
318
DPROD, 222, 230
DSIN, 288
dynaaminen tilanvaraus, 178
dynaamisesti varattava taulukko, 165
dynamic array, 165
E
ehdollinen suoritus, 86
ehtolause, 37
ehtorakenne, 321
eksponenttiesitys, 27, 199
eksponenttifunktiot, 71, 220
eksponenttinotaatio, 52, 57
ELEMENTAL, 115
elemental, 215
ELSE, 87, 321
ELSE IF, 87, 321
ELSEWHERE, 176, 255
Emacs, 20
Hakemisto
END, 47
END BLOCK DATA, 317
END DO, 90, 93, 286, 321
END FUNCTION, 100, 317
END IF, 87, 321
END INTERFACE, 147, 320
END MODULE, 129, 317
END PROGRAM, 25, 26, 47, 317
END SELECT, 88, 321
END SUBROUTINE, 104, 317
END TYPE, 319
ENTRY, 288
EOSHIFT, 177, 224
EPSILON, 132, 221
epsuora hyppylause, 286
.EQ., 77
EQUIVALENCE, 278, 279, 281, 288, 319
.EQV., 77, 78
Erastotheneen seula, 182
erikoismerkit, 46, 79
erisuuruus, 77
erityisnimi, 229231, 288
Esc -merkki, 255
esimerkkiohjelmat, 234
et-merkki, 46
etsint, 257
etumerkin vaihto, 67
etumerkki, 27
Euklideen algoritmi, 93
evoluutiostrategiat, 263
exclusive or, 76
EXIT, 91, 92, 94, 321
EXP, 220, 230
explicit interface, 116
explicit-shape array, 164, 171
EXPONENT, 221
EXTENDS, 296, 297
EXTERNAL, 47, 110, 113, 319, 320
external procedure, 108
EXTRINSIC, 305
F
FINAL, 294
xed source form, 44
FLOOR, 71, 222
FORALL, 177, 304, 305, 321
FORMAT, 47, 197, 284, 286, 323
format, 35
formatoimaton tiedonsiirto, 206
formatoitu tiedonsiirto, 206
Fortran 2003, 291
FORTRAN 66 -kieli, 23
FORTRAN 77 -kieli, 23
huonoja puolia, 276
333
muuntaminen Fortran 95:een, 275,

279
Fortran 95 -kieli, 23
siirtyminen kieleen, 275
FORTRAN IV -kieli, 23
FRACTION, 222
free source form, 44
FUNCTION, 47, 100, 317
function, 100
funktio, 99, 100, 320
kytt, 30, 100
mrittely, 30, 100
rekursiivinen, 111
taulukkoarvo, 173
funktiokutsu, 31, 101
G
.GE., 77
geneerinen
aliohjelma, 320
funktio, 320
nimi, 140
operaattori, 320
proseduuri, 140, 238
globaali data, 128
globaali muuttuja, 109
globaali optimointi, 264
GOTO-lause, 95, 322
.GT., 77
H
haarautuva hyppylause, 283, 284, 288
hakuavain, 257
heittomerkki, 46
High Performance Fortran, 25, 299
Hollerith-merkkijonovakiot, 287
host, 108
HPF, 25, 299
!HPF$, 299
HPF_LIBRARY, 300, 304
HUGE, 221, 282
huutomerkki, 46
hyppylause, 86, 95, 322
haarautuva, 283, 284, 288
I
IACHAR, 79, 223
IAND, 226, 227
IBCLR, 226
IBITS, 226
IBSET, 226
ICHAR, 79, 223
IEEE-liukulukuaritmetiikka, 69
IEOR, 226
IF-lause, 88
334
IF-rakenne, 37, 86, 87, 321

ikuinen silmukka, 91
IMPLICIT, 318, 319
implicit interface, 116
IMPLICIT NONE, 28, 47, 55, 109, 128,
277, 280, 318
implicit typing, 55
implied do list, 168
IMSL, 100
INCLUDE, 48
INDEPENDENT, 304
INDEX, 74, 209, 223, 230
INHERIT, 303
initialization expression, 54
inlining, 114
INQUIRE, 204, 207, 208, 322
inquiry functions, 215
insertion sort, 237
INT, 71, 81, 221, 231
INTEGER, 29, 51, 318
integer kind, 52
INTENT, 105, 106, 304, 319, 320
INTENT(IN), 106
INTENT(INOUT), 106
INTENT(OUT), 106
INTERFACE, 47, 116, 117, 123, 136,
147, 304, 320
INTERFACE
ASSIGNMENT, 146, 147, 149, 320
OPERATOR, 143, 145, 147, 149,
320
interface, 116
interface body, 121
internal procedure, 108
INTRINSIC, 47, 215, 319, 320
intrinsic function, 174
intrinsic type, 51
IOR, 226
ISHFT, 226
ISHFTC, 226, 227
ISO-standardi, 23
isot kirjaimet, 26, 45
isnt, 108
J
jakojnns, 94
jakolasku, 27, 67
jatkorivi, 36, 279, 280
jatkorivin merkki, 44
julkiset tunnukset, 133
julkisuus, 126, 131, 132, 159, 320
juurisolmu, 257
K
kaksiargumenttinen operaattori, 143,
147
Fortran 95/2003
kaksoispiste, 46
kaksoistarkkuus, 60
kanava, 35, 204, 323
ominaisuuksien kysely, 207
kanavanumero, 196, 204
karteesiset koordinaatit, 69
katkaisuoperaatiot, 71
kellonaika, 217, 219
kentn leveys, 144, 197
kertolasku, 27, 67
keskiarvo, 33, 34, 118
keskusmuisti, 18
keskusyksikk, 17
KIND, 221
kind, 56
KIND-parametri, 69
kirjoitus merkkijonoihin, 209
kokonaisluku, 51, 198
jakolasku, 27, 68
kokonaislukulaji, 52
kokonaislukumuuttuja, 28
kokonaislukutyyppi, 29, 51
kokonaislukuvakio, 27, 51
kommentti, 45
kommenttimerkki, 279, 280
kompleksiargumentti, 71
kompleksiluku, 51, 52, 58, 200
kompleksilukuvakio, 52, 217
komponenttiajattelu, 99
konekieli, 17
koneksky, 17
koodin optimointi, 21
koordinaattimuunnokset, 69
kosini, 71
kutsumuoto, 116, 136
mrittely, 116
kutsurajapinta, 99
kyselyfunktiot, 215
kysymysmerkki, 46
kyttjn mrittelem operaattori, 143
knnsaikaiset tarkistukset, 31, 110
knnslistaus, 20
kntj, 17
kntminen, 13, 19, 26, 40, 128
L
lainausmerkki, 27, 46, 53
laji, 52
lajimre, 56, 63
lajiparametri, 57, 58, 69
lajittelu, 80, 126, 237
nousuindeksi, 240
laskentajrjestys, 81
lause, 44
jrjess, 47
Hakemisto
jrjestys, 47
tiivistelm lauseista, 317
lausefunktio, 281, 288
lauseke, 67
lausenumero, 95, 322
LBOUND, 175, 179, 225
.LE., 77
LEN, 73, 74, 223, 230
LEN_TRIM, 74, 75, 223
LGE, 79, 223
LGT, 79, 223
Life-peli, 253
Life-soluautomaatti, 253
liitosoperaatio, 53, 73, 143
liittogradienttimenetelm, 269, 270
lineaariset yhtlryhmt, 269
linkitys, 19, 21
linkitystaulu, 21
list-directed formatting, 194
listan ohjaama muotoilu, 194
liukulukuesitys, 57
LLE, 79, 223
LLT, 79, 223
LOG, 220, 230
LOG10, 220, 230
logaritmifunktiot, 71, 220
LOGICAL, 51, 221, 318
looginen ekvivalenssi, 77
looginen epekvivalenssi, 77
looginen ja, 77
looginen negaatio, 77
looginen tai, 77
loogiset lausekkeet, 76, 77
loogiset operaatiot, 77
lopettaminen, 294
lopetusehto, 111
.LT., 77
luku merkkijonoista, 209
lhdekoodin muoto, 24, 44
lhdekooditiedosto, 19
M
matemaattiset funktiot, 222
MATMUL, 174, 225
matriisi, 168, 169
alkioiden summa, 174
alkioiden tulo, 174
tulo, 174
MAX, 222, 231
MAXEXPONENT, 221
MAXLOC, 175, 225
MAXVAL, 175, 225
MERGE, 176, 224
merkkien jrjestys, 79
merkkijono, 51, 53, 201
335
ksittely, 74, 223

lajittelu, 80
oletetun pituinen, 106
sijoitus, 82
vaihtelevan pituinen, 73
vertailu, 78
merkkijonomuuttujat, 73
merkkijonotaulukot, 75
merkkijonovakio, 27, 53
merkkitaulukot, 75
merkkityyppi, 53
merkkivalikoima, 45
Message-Passing Interface, 299
miinusmerkki, 46
MIL-STD 1753, 226
MIN, 222, 231
MINEXPONENT, 221
minimilevyinen kentt, 203
MINLOC, 175, 225
MINVAL, 175, 225
MOD, 94, 222, 230
modulaarinen ohjelmointi, 126
modulaarisuus, 126
MODULE, 47, 129, 317
MODULE PROCEDURE, 141, 147, 320
module procedure, 108
MODULO, 222
moduuli, 40, 48, 126
kytt, 129, 320
kyttmahdollisuudet, 148
vakioiden mrittely, 128
moduulin proseduuri, 108, 123, 317
MPI, 299
mukautuvan muotoinen taulukko, 165
muodollinen argumentti, 31, 101
muoto, 164
muotoilukoodi, 35, 144, 197199, 202,
323
kokonaisluvut, 198
kompleksiluvut, 200
merkkijonot, 201
mrittely, 323
reaaliluvut, 199
tiedon sytt, 198
yleinen, 201
muunnosfunktiot, 215
muuttuja, 28, 53
mrittely, 53, 318
nimi, 46
tyyppi, 29
muuttujien alustaminen, 107
muuttujien arvon silyminen, 107
MVBITS, 226, 227
mrittelylause, 319
336
Fortran 95/2003
NAG, 100, 117

NAGWare, 14
NAMELIST, 127, 148, 210, 254, 319
.NE., 77
NEAREST, 222
nelilaskin, 234
nelijuuri, 30, 71
.NEQV., 7678
NEW, 304
Newtonin menetelm, 90, 91
nimetty vakio, 33, 54, 63, 319
NINT, 71, 222, 230
nollakohdan haku, 135
NOPASS, 294
normaalijakautuneet satunnaisluvut,
138
NOT, 226
.NOT., 77
nousuindeksi, 240
NULL, 158, 186, 217
NULLIFY, 186, 322
numeerinen tarkkuus, 221
numeeriset funktiot, 222
numeeriset konversiot, 221
nkyvyysalue, 121, 122
nppimist, 18
omat funktiot, 30
ONLY, 133, 320
OPEN, 204206, 210, 322
OpenMP, 305
operaation mrittelyalueen laajentaminen, 140
operaattori, 83, 126
kaksiargumenttinen, 143
kyttjn mrittelem, 143
mrittely, 142, 147
yksiargumenttinen, 143, 144
ylilataaminen, 142
operator overloading, 142
optimointi, 21, 83, 84
optimointitehtvien ratkaiseminen, 263
OPTIONAL, 47, 119, 319, 320
optional, 118
.OR., 77, 78
osoitin, 183
kohde, 190
kohteesta irroitettu, 158
muuttuja, 178, 180, 183, 185, 186,
190
otsikkolause, 47, 101, 102
otsikkorivi, 31
overloading, 140
objektikooditiedosto, 19, 21
obsolescent feature, 284
ohjauskoodi, 202
ohjausrakenteet, 86
ohjelma, 17
ajaminen, 13, 40
konekielinen, 17
ohjelmayksikk, 127
perusrakenne, 44
pohjelma, 127
suorituksen keskeytys, 322
ohjelmakoodi, 19
rakenne, 44
ohjelmalohko, 86
ohjelmayksikiden mrittely, 317
ohjelmayksikk, 20, 127
ohjelmisto, 16
ohjelmointi, 16, 17
eri vaiheet, 18
ohjelmointikieli, 17
oikea sulje, 46
oletetun kokoinen taulukko, 172
oletetun muotoinen taulukko, 171
oletusarvoinen kutsumuoto, 116
oletusmuotoilu, 35, 194
olio-ohjelmointi, 295
PACK, 176, 183, 224

paikallinen muuttuja, 101, 109
paikallinen tunnus, 109
pallokoordinaatit, 69
PARAMETER, 33, 55, 63, 165, 280, 319
parametrisoitu tyyppimrittely, 56
PASS, 294
PAUSE, 287, 322
peruslaskutoimitukset, 27
perustyypit, 51, 63
lajimreet, 56
perkkisyys, 86
perkkissaantitiedosto, 206
PGM-formaatti, 251
pienempi kuin, 77
pienempi kuin -merkki, 46
pienet kirjaimet, 26, 45
pilkku, 46
pino, 235, 236
piste, 46
pituusyksikt, 128
plusmerkki, 46
poikkeusten ksittely, 94
POINTER, 178180, 183, 190, 319
Poissonin yhtl, 300
poistetut piirteet, 284
Hakemisto
portable graymap, 251

portable pixmap, 252
potenssiin korotus, 27, 67
potenssiinkorotusoperaattori, 68
PPM-formaatti, 252
PRECISION, 215, 221
PRESENT, 119, 217
PRINT, 193, 196, 323
PRIVATE, 131, 132, 134, 148, 319, 320
procedure, 100
PROD, 174
PRODUCT, 175, 225
PROGRAM, 25, 26, 47, 317
proseduuri, 99
alkioittainen, 115
argumenttien mreet, 320
argumenttina, 113
moduulin proseduuri, 130, 141
mrittelylauseet, 320
paluu kutsuvaan ohjelmayksikkn, 322
sisinen, 108
sivuvaikutukseton, 115
ulkoinen, 108, 110
prosenttimerkki, 46
PUBLIC, 132, 134, 319, 320
puolipiste, 44, 46
puolitushaku, 135, 136
PURE, 115
PVM, 299
pyristysoperaatiot, 71
pivmr, 217
pohjelma, 26, 47, 127
Q
Quicksort-algoritmi, 273
R
RADIX, 221
rakenteinen tietotyyppi, 152
rakenteinen tyyppi, 33, 34
mrittely, 319
rakenteiset tyypit, 296
random walk, 244
RANDOM_NUMBER, 39, 138, 139, 218,
245, 249
RANDOM_SEED, 218
RANGE, 221
rank, 164
reaaliluku, 27, 51, 52, 199
reaalilukulaji, 131
reaalilukutyyppi, 29
reaalilukuvakio, 27, 52
laji, 58
READ, 193, 196, 204, 323
337
REAL, 29, 51, 81, 221, 231, 318

REAL-funktio, 61, 62
REALIGN, 303
RECURSIVE, 111, 112, 317
REDISTRIBUTE, 303
rekursiivinen aliohjelma, 112
rekursiivinen funktio, 111
rekursiivinen proseduuri, 111
rekursio, 111
lopetusehto, 111
REPEAT, 144, 223
RESHAPE, 168, 175, 224, 289
RESULT, 100103, 111
RETURN, 94, 322
REWIND, 204, 206, 322
rinnakkaislaskenta, 25, 299
HPF, 299
OpenMP, 305
rivi, 44
RRSPACING, 221
ryhmittely, 27
S
sarakesidonnainen syttmuoto, 44,
277
sarjan summa, 60
satunnaiskulku, 244
satunnaisluvut, 218, 219
normaalijakautuneet, 138
SAVE, 108, 319, 320
SCALE, 221
SCAN, 74, 223
scope, 121
SELECT CASE, 88, 321
SELECT TYPE, 297
SELECTED_INT_KIND, 56, 57, 221
SELECTED_REAL_KIND, 57, 118, 221
selection sort, 80
SEQUENCE, 155, 296, 319
SET_EXPONENT, 221
SHAPE, 171, 175, 225
shape, 164
Shellsort-algoritmi, 241
sidontajrjestys, 67, 83
SIGN, 69, 222, 230
siirrettvyys, 17, 24
sijoituslajittelu, 237
sijoituslause, 29, 67, 81, 322
sijoitusoperaatio, 142
mrittely uudelleen, 146
sijoitusoperaattori, 147
silmukka, 90
silmukkamuuttuja, 32, 90
reaalilukutyyppi, 285
simulointi, 38
338
SIN, 140, 215, 220, 230, 288

SINH, 220, 230
sinifunktio, 71, 215
sisinen funktio, 31, 47, 101
sisinen proseduuri, 108, 123, 127,
317
sisinen tiedosto, 209
sivuvaikutukseton proseduuri, 115
sivuvaikutus, 83, 103
SIZE, 174, 175, 225, 237
skandinaaviset kirjaimet, 46, 79
sokkelo, 243
soluautomaatti
Life-peli, 253
yksiulotteinen, 247
SPACING, 221
specic name, 229, 288
SPREAD, 176, 224, 253
SQRT, 30, 222, 230
standard error, 205
standard input, 205
standard output, 205
standardi, 23, 25
standardialiohjelma, 114, 215
standardifunktio, 30, 69, 215
erityisnimi, 229, 288
standardioperaattori, 142
standardiproseduuri, 215
standardityypit, 51
statement function, 281, 288
STOP, 94, 322
storage association, 288
SUBROUTINE, 47, 104, 317
subroutine, 100, 104
sukupuu, 261
sulkumerkki, 27
sulut, 67
SUM, 34, 174, 175, 215, 225
suorasaantitiedosto, 206
suoritusjrjestys, 143
suorituskelpoinen ohjelma, 19
suurempi kuin, 77
suurempi kuin -merkki, 46
suurin yhteinen tekij, 93
syntaksi, 44
SYSTEM_CLOCK, 217
sytt, 192, 193, 323
ohjauskoodit, 202
syttkanava, 205
syttlause, 192, 193, 196
sytttiedot, 17
T
TAN, 220, 230
TANH, 220, 230
Fortran 95/2003
tapausrakenne, 321
tapausten ksittely, 88
TARGET, 184, 190, 319
tarkkuus, 69
taulukko, 33, 164
alkio, 166
alkioiden summa, 34
alkiojrjestys, 169
alustin, 168, 241
automaattinen, 165
dynaaminen, 165
indeksointi, 167
mrittely, 319
mukautuva, 165
muoto, 164
oletettu koko, 172
oletettu muoto, 171
operaatiot, 39, 174, 224, 225
rajojen tarkistukset, 21
standardifunktiot, 174
tunnettu muoto, 164, 171
ulottuvuudet, 164
vlitys, 170
vakio, 165
testaus, 19, 21
THEN, 87, 321
tiedon hakeminen, 257
tiedon jrjestminen, 256
tiedon sytt, 192, 198, 323
tiedon tulostaminen, 192, 323
tiedonsiirto, 193
erikoistilanteet, 95
tiedosto, 18
avaaminen, 204
ksittely, 204, 322
tietoabstraktio, 257
tietokone, 17
tietotyypit
abstraktit, 152
perustyypit, 51
rakenteiset, 152
tietueen osan tulostaminen tai lukeminen, 204
tiivistelm lauseista, 317
tilapistiedosto, 206
TINY, 221
todellinen argumentti, 31, 101
toisen asteen yhtl, 72
toisto, 86, 90
toistolista, 168
toistorakenne, 32, 321
top down, 99
totuusarvo, 51, 52
TRANSFER, 224, 279
Hakemisto
transformational functions, 215

TRANSPOSE, 174, 225
trigonometriset funktiot, 220
TRIM, 74, 75, 223
tulostaminen, 192, 193, 323
minimilevyinen kentt, 203
tulostuksen muotoilu, 35
tulostuksen ohjauskoodit, 202
tulostusasu, 35
tulostuskanava, 35
tulostuslause, 192, 193, 196
tulostuslista, 202, 203, 323
tunnettu kutsumuoto, 116
tunnetun muotoinen taulukko, 164,
171
tunniste
DO-rakenne, 93
IF-rakenne, 87
SELECT CASE -rakenne, 88
tunnus, 26, 45
nimeminen, 26
paikallinen, 109
tutkintaohjelma, 21
TYPE, 318, 319
TYPE IS, 297
tyyppi, 318
tyyppimrittelyn mreet, 319
U
UBOUND, 175, 225
ulkoinen proseduuri, 108, 110, 123,
127
geneerinen nimi, 142
ulottuvuudet, 164
unit, 35
UNPACK, 177, 224
USE, 47, 128, 132, 320
USE-lause, 133
uudet piirteet, 276
V
vaihtelevan pituinen merkkijono, 73
vaihtoehtoinen paluukohta, 286
vakio, 27
mrittely, 128
nimi, 46
tyyppi, 51
vakiotaulukko, 128, 165
valinnainen argumentti, 118, 119
valinta, 86
valintalajittelu, 80
vanhentuvat piirteet, 284
vapaa lhdekoodin muoto, 24, 44, 280
vasen sulje, 46
VERIFY, 74, 75, 223
339
versionhallintajrjestelm, 279
vertailuoperaatio, 77
vertailuoperaattori, 77, 78
vinoviiva, 46
virheenjljitysohjelma, 21
virheentarkistus, 110
virhetilanne, 94
virhetilanteiden ksittely, 210, 211
VT100, 255
vhennyslasku, 27, 67
vlilynti, 45, 46, 277
vltettvt piirteet, 287
W
WHERE, 176, 246, 255, 267, 321
World Wide Web, 14
WRITE, 25, 196, 204, 323
www, 14
Y
yhteenlasku, 27, 67
yhtlisyysmerkki, 46
yhtsuuruus, 77
yksiargumenttinen operaattori, 143,
144, 147
yksityisyys, 126, 131, 159, 320
yleinen muotoilukoodi, 201
ylilataaminen, 140, 156
yllpito, 19

LibroFortran95 2003 (OtroIdoma) (339s)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

LibroFortran95 2003 (OtroIdoma) (339s)

Uploaded by

Copyright:

Available Formats

For t r an 95/2003

Juha Haataja, Jussi Rahola ja Juha Ruokolainen

c Juha Haataja, Jussi Rahola, Juha Ruokolainen ja

Teoksen sislt ja merkinnt

Johdatus ohjelmointiin Fortran 95:ll

Ohjelmakoodin lauseiden jrjestys . . . . . . . . . . . . . . . .

11.14 Esimerkki: listarakenne . . . . . . . . . . . . . . . . . . . . . . . 187

15 Siirtyminen Fortran 95 -kieleen

Fortran 2003:n tuki olio-ohjelmoinnille . . . . . . . . . . . . . 296

17 Rinnakkaislaskenta HPF:ll ja OpenMP:ll

Ohjelmoinnin kultaiset snnt

Fortran 95:n hyvt, pahat ja rumat piirteet

Yhteenveto Fortran 95 -kielen lauseista

Tm oppikirja on tiivis johdatus ohjelmointiin Fortran-kielell. Teos on

1. Teoksen sislt ja merkinnt

1.2 Kytetyt merkinnt ja esimerkkiohjelma

Tm ohjelma lukee luvun x arvon ja tulostaa sinifunktion arvon SIN(x).

Tss tietokoneen kehote (prompt, merkki % yll) ja tulostus on ladottu

Tmn teoksen aihepiirist lydt listietoja World Wide Web -jrjestelmst

1. Teoksen sislt ja merkinnt

Alkurjhdyksest knnykkn: nkkulmia laskennalliseen tieteeseen

Kerromme tss luvussa tietokoneen toiminnasta ja ohjelmointikielten kytst tietokoneen ohjaamiseen.

Mihin tarvitaan ohjelmointia

Ohjelmointitaito on ers trkeimmist teknis-tieteellisill aloilla tarvittavista

2.2 Tietokoneet ja ohjelmointi

2.3 Mit tarkoitetaan tietokoneella

Ohjelmoinnin eri vaiheet

Kirjoita ohjelmakoodi pienin osasina, joista kukin tekee oman tehtvns

2.5 Ohjelman kntminen ja linkitys

Tss knnskomento oli nimeltn f90. Jos kytettviss on Fortran 95

Tss knsimme (ilman linkityst) ohjelmakoodin tiedostoissa ali.f90 ja

nksess lisksi tarkkaa Fortran 95:n mukaista syntaksitarkistusta, sill

3. Johdatus ohjelmointiin Fortran 95:ll

3.1 Fortran-kielen merkitys

olio-ohjelmointiin liittyvi ominaisuuksia. Seuraava pivitys standardiin on

Fortran 95:n trkeimmt uudet piirteet

Vanhaan Fortran-kieleen tottuneille nkyvin Fortran 95:n muutos on uuden

3. Johdatus ohjelmointiin Fortran 95:ll

3.3 Miksi Fortran-kielt kannattaa kytt

3.4 Fortran-ohjelman perusrakenne

saamme ohjelman knnetty ajokelpoiseksi ohjelmaksi Unix-koneissa tyypillisesti komennolla

Tiedoston nimi pttyy merkkeihin .f90, mist kntj tunnistaa tiedoston

Ohjelma siis tulosti laskutoimituksen 7 52 + 1 tuloksen.

Tmn ohjelman tulostus nytt tlt:

Siis lainausmerkeiss ( . . . ) ollut merkkijono tulostettiin sellaisenaan.

3. Johdatus ohjelmointiin Fortran 95:ll

3.6 Vakiot ja peruslaskutoimitukset

Operaatio / tekee jakolaskun. Tmn lauseen tulostus voisi olla

Tm lauseke tulostaa saman kuin edell. Merkint 0.52E2 tarkoittaa arvoa

Tm lause tulostaa seuraavaa:

merkkijono) tai kaksinkertaisilla lainausmerkeill ("merkkijono"). Jos

Edellisiss esimerkeiss kytettiin pelkstn ohjelmakoodiin sijoitettuja

Ensimminen WRITE-lause tulostaa kehotteen sytt muuttujalle i arvo.

3. Johdatus ohjelmointiin Fortran 95:ll

Tllin muuttuja i saa arvokseen kyttjn antaman luvun. Sama tehdn

Kyttj siis sytti ohjelmalle luvut 11 ja 13, ja ohjelma tulosti arvon 11

3.8 Muuttujien tyypit

Muuttujat k ja x ovat reaalilukuja ja muuttuja n on kokonaisluku. Ohjelma

Sijoituslauseella voimme antaa muuttujalle arvon. Seuraavassa on pieni esimerkkiohjelma:

Tss ohjelmassa mrittelimme kaksi reaalilukumuuttujaa rivill

Lauseella INTRINSIC SQRT kerrotaan, ett ohjelmassa kytetn Fortranin

Ohjelma tulostaa reaaliluvut kahdeksan numeron pituisina. Tulostetuissa

Omien funktioiden mrittely ja kytt