Kapitel 2. Fortran–programmering

(1)

1.7. Differentialekvationer

Differentialekvationerna spelar en stor roll i naturvetenskaperna. Man kan med fog säga, att en differentialekvation är den primitivaste tänkbara beskrivningen av ett naturfenomen. Alla differentialekvationer har ingalunda en analytisk lösning, och vi m˚aste därför ofta ty oss till en numerisk lösning.

Vad menar vi med l¨osningen till en differentialekvation? L˚at oss t.ex. betrakta ekvationen y⁰ = x² − y².

Intuitivt skulle man tänka sig en kurva y = y(x) i varje punkt (x, y), där kurvans tangent y⁰(x) uppfyller ekvationen ovan. Som vi ser, är det fr˚aga om en rent lokal egenskap. Det finns givetvis inte en enda kurva, som utgör lösning till differentialekvationen, utan istället passerar det en kurva, som utgör en lösning till ekvationen, genom varje punkt (x₀, y₀).

Denna tanke kan man ocks˚a ˚ask˚adliggöra grafiskt genom att man väljer olika punkter i (x, y)–planet och beräknar tangenten till kurvan genom punkten enligt ekvationen ovan. Dessa tangentsegment anger den riktning, som lösningskurvan har lokalt, och med en smula fantasi kan man skissera olika lösningskurvor om man har tillräckligt tätt med punkter i planet. Nedan visas ett dylikt ”riktningsfält” för ovanst˚aende differentialekvation (gjord med Matlab-programmet dfield):

(2)

För att förenkla metoden n˚agot, kan man söka efter de kurvor, längs vilka tangenterna har samma riktning (isoklinerna). I v˚art exempel finner vi, att isoklinerna är en hyperbelskara:

x² − y² = k.

Denna grafiska metod är ganska grov, men den kan likväl ge en ganska god föreställning om problemets natur, vilket kan underlätta den numeriska lösningen.

Om vi endast önskar beräkna en lösningskurva, som g˚ar genom en given punkt är det onödigt att rita hela riktningsfältet. Vi kan d˚a göra p˚a det sätt som visas i figuren nedan.

(3)

Först uppritas ett segment av en tangent till kurvan, som g˚ar genom den givna punkten, därp˚a en ny tangent som g˚ar genom segmentets ändpunkt etc. Vi f˚ar p˚a detta sätt den polygonb˚age, som visas i figuren.

Som vi ser fungerar denna metod inte alltid s˚a bra, beroende p˚a att vi alltid använder föreg˚aende tangent för att beräkna nästa punkt p˚a kurvan, vilket leder till ett systematiskt fel, om man inte väljer punkterna mycket tätt.

Det vore därför förnuftigare att kasta en blick fram˚at, beräkna tangenten där, och därp˚a fortsätta i den riktning, som bestäms av medeltalet av de b˚ada tangentriktningarna. Denna idé ligger till grund för en klass av numeriska metoder för att lösa differentialekvationer, som brukar kallas prediktor-korrektor–metoder.

(4)

Den första som uppfann en numerisk metod för att lösa differentialekvationer av första ordningen var Leonhard Euler¹. Denna metod vidareutvecklades av Cauchy under föreläsningar i École Polytechnique². Idén är följande: Vi utg˚ar fr˚an ekvationen

dy

dt = f (t, y),

under antagande av randvillkoret y(t₀) = y₀. Vi antar ytterligare, att f och ^∂f_∂y är reella och kontinuerliga funktioner inom rektangeln |t − t0| ≤ a, |y − y0| ≤ b, och att sampelpunkterna tk = t₀ + hk är givna. Man kan d˚a definiera en räcka av funktionsvärden y0, y₁, . . . , y_n med hjälp av rekursionslikheten

y_i+1 = y_i + hf (t_i, y_i), (i = 0, 1, . . . , n − 1).

Cauchy visade, att under dessa omständigheter kommer den polygonb˚age, som definieras av punkterna (t₀, y₀), (t₁, y₁), . . . att konvergera mot differentialekvationens lösning. Cauchys konvergensvillkor vidareutvecklades och förbättrades sedermera av Lifschitz (1877).

1L. Euler: De Integratione Aequationum Differentialium per Approximationem, 1768-1769

2F. Moigno: Lec cons de calcul différentiel et de intégral, rédigées d’aprés les méthodes et les ouvrages publiés ou inédits de M. A. L. Cauchy, 4 vol., Paris, 1840-1861

(5)

Eulers metod f¨oljer av Taylor–utvecklingen

y(t₀ + h₀) ≈ y(t₀) + h₀y⁰(t₀) = y₀ + h₀f (t₀, y₀), om vi v¨aljer

y₁ = y₀ + h₀f (t₀, y₀)

som approximation för lösningen vid tiden t₁. Parametern h₀ > 0 kallas steglängden. Vi kan göra ett steg till med steglängden h1 genom en Taylor–utveckling kring punkten t = t₁:

y(t₁ + h₁) ≈ y(t₁) + h₁y⁰(t₁) = y(t₁) + h₁f (t₁, y(t₁)).

Eftersom vi inte känner den exakta lösningen i t = t₁, s˚a kan vi inte beräkna högra membrum av denna ekvation, men om vi använder approximationerna y1 ≈ y(t₁) och f₁ = f (t₁, y₁) ≈ f (t₁, y(t₁)) s˚a kan vi uttrycka lösningen i t₂ = t₁ + h₁ som

y(t₂) ≈ y₂ = y₁ + h₁f₁.

Vi ser nu den allmänna principen. I varje steg beräknas f i den approximativa lösningspunkten (t_n, y_n), och sedan används tangenten till kurvan för att beräkna yn+1:

y_n+1 = y_n + h_nf (t_n, y_n).

(6)

Den upprepade användningen av denna ekvation definierar Eulers metod. Ett enkelt MATLAB–program (där hn = h) skulle kunna se ut s˚a här:

function y = eultest(fname,h,y0,t0,n)

% Invariabler:

% fname : namn p˚a funktionen

% h : stegl¨angd

% y0(t0): begynnelsev¨arde

% n : max antal steg

k = 0;

tn = t0;

yn = y0;

while k <= n

disp(sprintf(’%3.0f %10.7f %10.7f’, k, tn,yn)) tn = tn + h;

fn = feval (fname,tn, yn);

yn = yn + h*fn;

k = k + 1;

end

(7)

Problemet med Eulers metod är att h (=intervallets längd) m˚aste väljas litet för att metoden skall fungera.

F¨or att belysa detta problem, studerar vi ekvationen dy

dx = e^−y − x², y(0) = 0 som l¨oses med Eulers metod f¨or t = 0, h, 2h, . . ., nh = 1 (h = 0.05, 0.1, 0.2 och 0.3). Resultatet visas i nedanst˚aende tabell.

Exakt l¨osn. Eulers approximativa metod

x y h = 0.05 h = 0.10 h = 0.2 h = 0.3

0.0 0.0

0.1 0.09498 0.09694 0.09900 - -

0.2 0.17977 0.18261 0.18557 0.19200 -

0.3 0.25389 0.25672 0.25964 - 0.27300

0.4 0.31667 0.31872 0.32077 0.32505 -

0.5 0.36731 0.36786 0.36833 - -

0.6 0.40488 0.40329 0.40152 0.39756 0.39333

0.7 0.42839 0.42407 0.41942 - -

0.8 0.43686 0.42923 0.42119 0.40395 -

0.9 0.42929 0.41782 0.40582 - 0.35277

1.0 0.40477 0.38895 0.37246 0.33749 -

(8)

I figuren nedan har den exakta kurvan, samt de ber¨aknade kurvorna f¨or h = 0.1 och h = 0.2 ritats med MATLAB som funktion av t:

Tabellen och figuren visar, att felet är starkt beroende av steglängden. En kortare steglängd ger noggrannare resultat, men samtidigt ökar antalet funktionsberäkningar, vilket förlänger räknetiden.

Felet i Eulers metod kan vi studera genom att välja en konstant steglängd h och anta, att y_n−1 är exakt.

Genom att subtrahera y_n = y_n−1 + hf_n−1 fr˚an Taylor–utvecklingen

y(t_n) = y_n−1 + hy⁰(t_n−1) + h²

2 y⁰⁰(θ),

(9)

d¨ar tn−1 ≤ θ ≤ tn, f˚ar vi

y(t_n) − y_n = h²

2 y⁰⁰(θ),

som kallas det lokala avkortningsfelet. Detta fel kan man först˚a s˚a, att punkten (t_n, y_n) befinner sig p˚a en viss lösningskurva y_n(t), som satisfierar differentialekvationen y⁰(t) = f (t, y(t)). Med nästa steg kommer vi över till en ny lösningskurva, och hoppets storlek är lika med det lokala avkortningsfelet.

Om felet är proportionellt mot h^k+1, brukar man säga, att metoden är av ordningen k; därför är Eulers metod av ordningen 1. Det finns ocks˚a ett globalt fel, som är den verkliga skillnaden mellan den beräknade lösningen y_n för t = t_n, och den sanna lösningen y(t_n): g_n = y(t_n) − y_n.

Metodens stabilitet inverkar ocks˚a p˚a beräkningen. Om vi t.ex. tillämpar Eulers metod p˚a differentialekvationen y⁰(t) = −10y(t), s˚a blir iterationsformeln y_n+1 = (1 − 10h)y_n. För att inte felet skall växa under iterationsprocessen, s˚a m˚aste vi fordra att |1 − 10h| < 1, allts˚a t.ex. h < 1/5. Om detta kriterium är uppfyllt, s˚a är metoden stabil. Om däremot h > 1/5, s˚a kommer ett fel δ i utg˚angsvillkoren att leda till ett fel av storleken (1 − 10h)ⁿδ vid den n:te iterationen.

För att först˚a stabilitetsbegreppet bättre, skall vi studera en variant av Eulers metod, som kallas Eulers baklänges metod.

(10)

Om vi utg˚ar fr˚an approximationen

y(t_n+1 + h) ≈ y(t_n+1) + y⁰(t_n+1)h = y(t_n+1) + f (t_n+1, y(t_n+1))h och s¨atter h = −hn = t_n − t_n+1, s˚a f˚ar vi

y(t_n) ≈ y(t_n+1) − h_nf (t_n+1, y(t_n+1)).

Om vi substituerar y_n istället för y(t_n), och y_n+1 istället för y(t_n+1), s˚a f˚ar vi formeln y_n+1 = y_n + h_nf (t_n+1, y_n+1),

som beskriver iterationerna i Eulers bakl¨anges metod.

Eulers baklänges metod är en implicit metod eftersom den ger en implicit definition för y_n+1. Om t.ex.

y⁰ = ay s˚a har vi

y_n+1 = y_n + h_nay_n+1 = 1

1 − h_nay_n,

s˚a att metoden är stabil för alla positiva steglängder, om a < 0. Eulers vanliga metod är en explicit metod, eftersom y_n+1 definierats explicit med hjälp av tidigare beräknade storheter. Implicita metoder har i allmänhet bättre stabilitet än explicita metoder.

(11)

I Eulers metod använder man i varje steg endast ett värde av funktionen f (t, y). I en Runge–Kutta metod räknar man ut flere funktionsvärden, innan man gör ett steg fram˚at. En metod som använder tv˚a funktionsberäkningar (dvs är av andra ordningen) kan t.ex. skrivas

k₁ =hf (t_n, y_n)

k₂ =hf (t_n + αh, y_n + βk₁) y_n+1 =y_n + ak₁ + bk₂,

där α, β, a och b är parametrar, som kan bestämmas s˚a, att felet är av storleksordningen O(h³). En Taylor–utveckling av y(t_n+1) = y(t_n + h) ger

y(t_n+1) = y(t_n) + y⁰(t_n)h + y⁰⁰(t_n)h²

2 + O(h³).

Emedan

y⁰(t_n) =f (t_n, y_n) ≡ f y⁰⁰(t_n) =∂f

∂t + ∂f

∂y · dy

dt = ∂f (t_n, y_n)

∂t + ∂f (t_n, y_n)

∂y f (t_n, y_n) ≡ f_t + f_yf,

(12)

(totala derivatan!) s˚a f˚ar vi

y(t_n+1) = y(t_n) + f h + (f_t + f_yf )h²

2 + O(h³).

˚A andra sidan ¨ar

k₂ =hf (t_n + αh, y_n + βk₁) = h(f (t_n, y_n) + αh∂f

∂t + βk₁∂f

∂y + O(h²))

=h(f + αhf_t + βk₁f_y + O(h²)), varf¨or

y_n+1 = y_n + ak₁ + bk₂ = y_n + (a + b)f h + b(αf_t + βf f_y)h² + O(h³).

Det lokala avrundningsfelet antas vara O(h³), dvs y(t_n+1) − y_n+1 = O(h³). H¨arav f¨oljer a + b =1

2bα =1 2bβ =1,

(13)

som har ett oändligt antal lösningar, men den enklaste är a = b = 1/2 och α = β = 1. Med detta val f˚ar vi Runge–Kutta metoden av andra ordningen:

k₁ =hf (t_n, y_n)

k₂ =hf (t_n + h, y_n + k₁) y_n+1 =y_n + (k₁ + k₂)/2.

Ofta används Runge–Kutta metoder av högre ordning. Den kändaste är Runge–Kutta metoden av fjärde ordningen:

k₁ =hf (t_n, y_n) k₂ =hf (t_n + h

2, y_n + ¹₂k₁) k₃ =hf (t_n + h

2, y_n + ¹₂k₂) k₄ =hf (t_n + h, y_n + k₃) y_n+1 =y_n + 1

6(k₁ + 2k₂ + 2k₃ + k₄)

(14)

Denna metod beh¨over fyra f –ber¨akningar per steg.

Här är en MATLAB–funktion som gör ett Runge–Kutta steg av angiven ordning:

function [tn, yn, fn] = RKsteg(fname, tc,yc,fc,h,k)

% Invariabler:

% fname : str¨ang som inneh˚aller namnet p˚a en funktion av formen

% f(t,y), d¨ar t ¨ar ett tal och y en kolumnvektor

% yc : en approximativ l¨osning av y’(t) = f(t,y(t)) i t=tc.

% fc : f(tc,yc).

% h : stegl¨angden.

% k : ordningen av Runge-Kutta metoden (1<=k<=4)

% Utvariabler:

% tn : tc+h, yn ¨ar en approximativ l¨osning i t=tn,och

% fn : f(tn,xn).

if k==1

k1 = h*fc;

yn = yc +k1;

elseif k==2 k1 = h*fc;

(15)

k2 = h*feval(fname,tc+(h/2),yc+(k1/2));

yn = yc + (k1+k2)/2;

elseif k==3 k1 = h*fc;

k3 = h*feval(fname,tc+h,yc-k1+2*k2);

yn = yc + (k1 + 4*k2 +k3)/6;

elseif k==4 k1 =h*fc;

k4 = h*feval(fname,tc+h,yc+k3);

yn = yc + (k1 + 2*k2 + 2*k3 +k4)/6;

end

tn = tc + h;

fn = feval(fname,tn,yn);

MATLAB har tv˚a inbyggda Runge–Kutta funktioner, ode23 och ode45 (rekommenderas), som kombinerar Runge–Kutta metoder av andra och tredje ordningen, resp. fj¨arde och femte ordningen.

(16)

Kapitel 2. Fortran–programmering

Härefter skall vi överg˚a till att studera programmering i Fortran, som är det äldsta programmeringsspr˚aket för vetenskapliga beräkningar, som fortfarande används vid krävande numeriska beräkningar. Vi börjar med en kort översikt av programmeringens historia.

(17)

2.1. Programmeringsspr˚ ak

Ursprungligen programmerades datorerna p˚a det enda spr˚ak de förstod, nämligen binärkod. Som ett exempel p˚a en dylik maskinkod visas nedan ett litet program för en PC-kompatibel dator, som har till uppgift att filtrera bort den ˚attonde biten i en textfil:

1CED:0100 B407 MOV AH,07

1CED:0102 CD21 INT 21

1CED:0104 247F AND AL,7F

1CED:0106 88C2 MOV DL,AL

1CED:0108 B406 MOV AH,06

1CED:010A CD21 INT 21

1CED:010C 3C1A CMP AL,1A

1CED:010E 75F0 JNZ 0100

1CED:0110 CD20 INT 20

De nio första kolumnerna till vänster i ovanst˚aende listning anger adressen i minnet där den maskinkodade instruktionen (kolumn 11-14) har lagrats. Instruktionen är angiven i hexadecimalkod, som har 16 som bas.

L¨angst till h¨oger st˚ar den motsvarande symboliska instruktionskoden, uttryckt p˚a assembler–spr˚aket.

(18)

Assemblerspr˚aket är maskinberoende, och ursprungligen bara ett sätt att symboliskt uttrycka de maskinkodade instruktionerna (senare infördes bl.a. ocks˚a makroinstruktioner i de olika assemblerspr˚aken, för att underlätta programmeringen). P˚a grund av att ett program som skrivits p˚a ett assemblerspr˚ak inte kan

överföras till en annan dator, och assemblerprogrammen dessutom oftast är l˚anga och invecklade, ins˚ag man redan tidigt vikten av att uppfinna högre programmeringsspr˚ak, som var enklare att använda, och dessutom ocks˚a möjliggjorde överföring av program mellan olika datorer.

Det första av dessa programmeringsspr˚ak var FORTRAN (namnet var en akronym för IBM Mathematical FORmula TRANslation System), som utvecklades av IBM under ledning av John Backus ˚ar 1954 för den nya datorn IBM 704, som hade h˚ardvara för flyttalsberäkningar. Ursprungligen var det meningen att använda spr˚aket p˚a bara en dator, men d˚a IBMs kunder fick höra om det, ville alla ha det.

FORTRAN-spr˚aket är uppbyggt av enkla engelska ord och matematiska termer. För att ett program skrivet p˚a FORTRAN skulle kunna först˚as av datorn, m˚aste det översättas till maskinkod, som är det enda spr˚ak som datorn kan först˚a. För den skull m˚aste man utveckla ett särskilt program, en kompilator.

Den första programmeringshandboken för FORTRAN kom ut 1956, och den följdes av en kompilator ˚aret därp˚a. ˚Ar 1958 kom IBM ut med en ny förbättrad version av spr˚aket, som kallades FORTRAN II, och som kunde användas p˚a IBMs nya datorer (709, 650, 1620 och 7070). Spr˚akets stora framg˚ang ledde till att ocks˚a andra datortillverkare började skriva FORTRAN-kompilatorer för sina datorer.

(19)

Man började snart inse behovet av en allmänt erkänd standard för spr˚aket, som skulle göra det lättare att överföra program mellan olika datorer. IBM gick ett steg i denna riktning genom FORTRAN IV, som blev färdig 1962, och som var i det närmaste datoroberoende. Det amerikanska standardiseringsinstitutet (ANSI) färdigsställde den första standarden för FORTRAN ˚ar 1966 (som ibland kallas FORTRAN 66), och en ny standard, FORTRAN 77, blev godkänd ˚ar 1978.

Trots alla sina brister (som under ˚arens lopp bättrats p˚a) är FORTRAN fortfarande ett av de populäraste spr˚aken för vetenskapliga beräkningar. ˚Ar 1990 gjordes en uppskattning, enligt vilken 70 % av alla program var skrivna p˚a COBOL (”COmmon Business Oriented Language”, det vanligaste spr˚aket i affärsvärlden), och ca 60 % av ˚aterstoden var skrivna p˚a FORTRAN, resten var skrivna p˚a andra spr˚ak. En ny standard, Fortran 90, publicerades i augusti 1991, och har s˚a m˚anga utvidgningar och förbättringar, att den i viss m˚an kan karaktäriseras som ett nytt spr˚ak (observera även, att namnet skrivs med sm˚a bokstäver). Att Fortran kanhända nu upplever en renässans visas ocks˚a av att en förbättrad standard, Fortran 2003, har blivit färdig.

Bl.a. kritiken mot FORTRAN som programmeringsspr˚ak ledde till att en kommitté, där även John Backus ingick, ˚ar 1960 publicerade en beskrivning av ett nytt algoritmiskt spr˚ak ALGOrithmic Language, Algol 60, och man hoppades, att det skulle innebära en en förnyelse av den vetenskapliga programmeringstekniken.

Bland annat skulle det vara lätt att läsa ALGOL-program, s˚a att man skulle kunna använda detta spr˚ak för att beskriva olika räknemetoder.

(20)

Algol inneh¨oll b˚ade sm˚a och stora bokst¨aver, samt speciella matematiska symboler, s˚asom + - = > <

≥ ≤. Tecknet ÷ angav en speciell heltalsdivision, och := betecknade substitution, s˚asom x := 5. Av n˚agon anledning blev dock inte Algol s˚a populärt som man hade väntat sig, även om det implementerades p˚a m˚anga datorer och användes l˚angt in p˚a 1970–talet. Idéerna som l˚ag till grund för Algol blev dock inspirationskälla för andra spr˚ak, s˚asom C och Pascal.

Pascal utvecklades av Niklaus Wirth i Zürich ˚ar 1971. Spr˚aket gavs avsiktligt fr˚an början en systematisk och logisk uppbyggnad, s˚a att det skulle vara lättare att skriva ”bra”program. Ocks˚a en effektiv kompilator (översättningsprogram) planerades. Pascal-kompilatorer introducerades p˚a m˚anga datorer, och det inlärdes ofta som första programmeringsspr˚ak. För verkligt krävande numeriska uppgifter är Pascal dock inte lika effektivt som Fortran, och numera även C. En intressant vidareutveckling av Pascal är Modula-2, som Niklaus Wirth introducerade ˚ar 1980. Detta spr˚ak understöder den moderna objektorienterade programmeringstekniken, och närmar sig ocks˚a i vissa fall maskinkoden, liksom C.

C-spr˚aket konstruerades av Dennis Ritchie i AT& T ˚ar 1972. Det utvecklades ur ett äldre spr˚ak, som kallades BCPL. Detta spr˚ak bildade även grunden för en föreg˚angare till C-spr˚aket, som kallades ’B’ efter första bokstaven i BCPL. C-spr˚aket fick sitt namn efter andra bokstaven i BCPL, och definierades i boken ”The C Programming Language”, skriven av Kernigan och Ritchie ˚ar 1978. 1990 utkom ocks˚a en ANSI-standard.

(21)

C har en mycket koncis syntax, antagligen beroende p˚a att det utvecklats p˚a datorer med l˚angsamma teletype-terminaler. C är ett mycket effektivt spr˚ak, men med C är det ocks˚a lätt att göra programmeringsfel (som kan vara sv˚ara att finna).

Genom objekt-orienterad programmering (OOP) som nu är p˚a modet, har ett antal nya begrepp, s˚asom klasser, objekt, metoder, etc. introducerats i programmeringen. Det första spr˚aket som innehöll s˚adana begrepp var Simula. C⁺⁺, som numera anses vara ett av de populäraste programmeringsspr˚aken utvecklades av Stroustrup, och standardiserades 1997. Där har man försökt kombinera Simulas funktionalitet med C- spr˚akets effektivitet.

BASIC (Beginner’s All-purpose Symbolic Instruction Code), som utvecklades i Dartmouth College ˚ar 1965 av John Kemeny och Thomas Kurtz, är ett spr˚ak, som har varit populärt p˚a grund av den l˚aga inlärningströs- keln, samt genom att det kan tjäna som inkörningsport till FORTRAN. Ursprungligen fanns BASIC enbart som ett tolkande program, dvs instruktionerna översattes var för sig, istället för att hela programmet skulle

översättas p˚a en g˚ang. Detta gjorde utförandet av programslingor särskilt l˚angsamma. Genom att BASIC alltid förekom p˚a de första mikrodatorerna under 1970–talet ökades intresset för programmering märkbart.

Efter denna kortfattade inledning skall vi diskutera hur man i allmänhet förfar, när man skall skriva ett program p˚a ett högniv˚aspr˚ak s˚asom Fortran eller Pascal. Först brukar man specificera problemet, s˚a att man f˚ar klart för sig vad programmmet bör göra. Utg˚aende fr˚an specifikationen väljer man de metoder och algoritmer som man skall använda i programmet.

(22)

Följande steg är att koda (skriva) programmet (i praktiken skrivs programmet in i en fil med hjälp av en editor), varp˚a det är klart för kompilering (dvs översättning) till maskinkod. Under kompileringen granskas programmets syntax, dvs att man följt spr˚akets regler vid kodningen. Om kompilatorn upptäcker n˚agra fel (kompileringsfel), bör dessa rättas innan man kan g˚a vidare. Det översatta programmet kallas ofta relokerbart, eftersom programmets startadress ännu inte blivit bestämd, utan alla adresser i koden är relativa. Först när programmet laddas, räknas startadressen ut.

Kompileringen äger vanligen rum i flera faser. Innan syntaxgranskningen och den egentliga översättningen p˚abörjas, uppställer kompilatorn tabeller över symboler som används i programmet och ordnar dem i kat- egorier. Numera är det ocks˚a viktigt med optimering av programkoden. Det är oftast möjligt att antingen optimera programmets snabbhet, eller det utrymme i minnet det upptar. Vilket man väljer, beror p˚a vad programmet skall användas till. Kompilatorer p˚a moderna superdatorer kan dessutom vektorisera koden, eller göra det möjligt att köra delar av den parallellt, varigenom programmet blir snabbare. För att under- lätta programmeringen av massivt parallella datorer har man gjort en utvidgning av Fortran-spr˚aket (High Performance Fortran, HPF).

När programmet har översatts, skall det länkas, dvs objektfilerna (som inneh˚aller relokerbar kod) kombin- eras med varandra och eventuellt med yttre biblioteksfiler. M˚anga kompilatorer, särskilt p˚a UNIX-datorer, inneh˚aller en linkoption, som ofta är underförst˚add, men p˚a m˚anga datorer m˚aste man starta ett särskilt länkningsprogram. Detta kan vara nödvändigt isynnerhet om programmet best˚ar av flere moduler.

(23)

Tidigare, när datorernas minne ofta var mycket begränsat, kunde länkningsprogrammet ocks˚a dela upp den exekverbara filen p˚a flere delar, eller överlagringar (overlays), som lästes in i minnet efterhand som de behövdes. Detta behöver man numera sällan bekymra sig, eftersom m˚anga datorer har virtuellt minne, dvs primärminnet inneh˚aller vanligen endast en del av programmet, men laddar vid behov automatiskt ner ytterligare ”sidor” (innebär ett sätt att uppdela minnet).

När programmet är färdigt översatt, bör det testas. Detta sker oftast med användning av särskilda testdata.

Fel, som upptäckts under testkörningen, kallas exekveringsfel, och de är ofta sv˚arare att hitta än syntaxfelen.

Detta skede i programutvecklingen brukar kallas felsökningen (eng. ”debug”). När man rättat felen, upprepas testningen p˚a nytt, tills inga fel längre visar sig. D˚a programmet till sist fungerar, brukar man dokumentera det (ett steg som stundom blir bortglömt).

Förr skrevs program ofta som stora helheter, vilket ledde till att felsökningen försv˚arades när programmen växte. Numera programmerar man oftast modulärt, vilket innebär, att programmet delas upp i delar, som testas var för sig. Slutligen sammanfogas delarna (modulerna) till en helhet, som underg˚ar den slutliga testningen. Detta gör det mycket lättare att skriva stora program. Modulerna kan göras ganska sm˚a, de kan t.ex. best˚a av en eller ett par subrutiner. Modulär programmering leder till separat kompilering, som numera är möjlig med de flesta kompilatorer. M˚anga UNIX-datorer använder dessutom prekompilatorer, som har till uppgift att behandla särskilda kompilatordirektiv, som finns i programtexten.