1.7. Differentialekvationer

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åste därför ofta ty oss till en numerisk lösning. Vad menar vi med lösningen till en differentialekvation? Låt oss t.ex. betrakta ekvationen y = x 2 y 2. 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åga 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 0, y 0 ). Denna tanke kan man också åskådliggö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ående differentialekvation (gjord med Matlab-programmet dfield): Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 1

För att förenkla metoden något, kan man söka efter de kurvor, längs vilka tangenterna har samma riktning (isoklinerna). I vårt exempel finner vi, att isoklinerna är en hyperbelskara: x 2 y 2 = 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år genom en given punkt är det onödigt att rita hela riktningsfältet. Vi kan då göra på det sätt som visas i figuren nedan. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 2

Först uppritas ett segment av en tangent till kurvan, som går genom den givna punkten, därpå en ny tangent som går genom segmentets ändpunkt etc. Vi får på detta sätt den polygonbåge, som visas i figuren. Som vi ser fungerar denna metod inte alltid så bra, beroende på att vi alltid använder föregående tangent för att beräkna nästa punkt på 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åt, beräkna tangenten där, och därpå fortsätta i den riktning, som bestäms av medeltalet av de båda 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. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 3

Den första som uppfann en numerisk metod för att lösa differentialekvationer av första ordningen var Leonhard Euler 1. Denna metod vidareutvecklades av Cauchy under föreläsningar i École Polytechnique2. Idén är följande: Vi utgår från ekvationen dy dt = f(t, y), under antagande av randvillkoret y(t 0 ) = y 0. Vi antar ytterligare, att f och f y är reella och kontinuerliga funktioner inom rektangeln t t 0 a, y y 0 b, och att sampelpunkterna t k = t 0 + hk är givna. Man kan då definiera en räcka av funktionsvärden y 0, y 1,..., 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åge, som definieras av punkterna (t 0, y 0 ), (t 1, y 1 ),... att konvergera mot differentialekvationens lösning. Cauchys konvergensvillkor vidareutvecklades och förbättrades sedermera av Lifschitz (1877). 1 L. Euler: De Integratione Aequationum Differentialium per Approximationem, 1768-1769 2 F. 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 Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 4

Eulers metod följer av Taylor utvecklingen om vi väljer y(t 0 + h 0 ) y(t 0 ) + h 0 y (t 0 ) = y 0 + h 0 f(t 0, y 0 ), y 1 = y 0 + h 0 f(t 0, y 0 ) som approximation för lösningen vid tiden t 1. Parametern h 0 > 0 kallas steglängden. Vi kan göra ett steg till med steglängden h 1 genom en Taylor utveckling kring punkten t = t 1 : y(t 1 + h 1 ) y(t 1 ) + h 1 y (t 1 ) = y(t 1 ) + h 1 f(t 1, y(t 1 )). Eftersom vi inte känner den exakta lösningen i t = t 1, så kan vi inte beräkna högra membrum av denna ekvation, men om vi använder approximationerna y 1 y(t 1 ) och f 1 = f(t 1, y 1 ) f(t 1, y(t 1 )) så kan vi uttrycka lösningen i t 2 = t 1 + h 1 som y(t 2 ) y 2 = y 1 + h 1 f 1. 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 y n+1 : y n+1 = y n + h n f(t n, y n ). Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 5

Den upprepade användningen av denna ekvation definierar Eulers metod. Ett enkelt MATLAB program (där h n = h) skulle kunna se ut så här: function y = eultest(fname,h,y0,t0,n) % Invariabler: % fname : namn på funktionen % h : steglängd % y0(t0): begynnelsevärde % 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 Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 6

Problemet med Eulers metod är att h (=intervallets längd) måste väljas litet för att metoden skall fungera. För att belysa detta problem, studerar vi ekvationen dy dx = e y x 2, y(0) = 0 som löses med Eulers metod för t = 0, h, 2h,..., nh = 1 (h = 0.05, 0.1, 0.2 och 0.3). Resultatet visas i nedanstående tabell. Exakt lösn. 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 - Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 7

I figuren nedan har den exakta kurvan, samt de beräknade kurvorna för 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ån Taylor utvecklingen y(t n ) = y n 1 + hy (t n 1 ) + h2 2 y (θ), Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 8

där t n 1 θ t n, får vi y(t n ) y n = h2 2 y (θ), som kallas det lokala avkortningsfelet. Detta fel kan man förstå så, att punkten (t n, y n ) befinner sig på 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å 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å på beräkningen. Om vi t.ex. tillämpar Eulers metod på differentialekvationen y (t) = 10y(t), så blir iterationsformeln y n+1 = (1 10h)y n. För att inte felet skall växa under iterationsprocessen, så måste vi fordra att 1 10h < 1, alltså t.ex. h < 1/5. Om detta kriterium är uppfyllt, så är metoden stabil. Om däremot h > 1/5, så kommer ett fel δ i utgångsvillkoren att leda till ett fel av storleken (1 10h) n δ vid den n:te iterationen. För att förstå stabilitetsbegreppet bättre, skall vi studera en variant av Eulers metod, som kallas Eulers baklänges metod. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 9

Om vi utgår från 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ätter h = h n = t n t n+1, så får vi y(t n ) y(t n+1 ) h n f(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å får vi formeln y n+1 = y n + h n f(t n+1, y n+1 ), som beskriver iterationerna i Eulers baklänges 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å har vi 1 y n+1 = y n + h n ay n+1 = 1 h n a y n, så 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. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 10

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åt. En metod som använder två funktionsberäkningar (dvs är av andra ordningen) kan t.ex. skrivas k 1 =hf(t n, y n ) k 2 =hf(t n + αh, y n + βk 1 ) y n+1 =y n + ak 1 + bk 2, där α, β, a och b är parametrar, som kan bestämmas så, att felet är av storleksordningen O(h 3 ). En Taylor utveckling av y(t n+1 ) = y(t n + h) ger Emedan y (t n ) =f(t n, y n ) f y(t n+1 ) = y(t n ) + y (t n )h + y (t n ) h2 2 + O(h3 ). y (t n ) = f t + f y dy dt = f(t n, y n ) t + f(t n, y n ) f(t n, y n ) f t + f y f, y Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 11

(totala derivatan!) så får vi Å andra sidan är varför y(t n+1 ) = y(t n ) + fh + (f t + f y f) h2 2 + O(h3 ). k 2 =hf(t n + αh, y n + βk 1 ) = h(f(t n, y n ) + αh f t + βk f 1 y + O(h2 )) =h(f + αhf t + βk 1 f y + O(h 2 )), y n+1 = y n + ak 1 + bk 2 = y n + (a + b)fh + b(αf t + βff y )h 2 + O(h 3 ). Det lokala avrundningsfelet antas vara O(h 3 ), dvs y(t n+1 ) y n+1 = O(h 3 ). Härav följer a + b =1 2bα =1 2bβ =1, Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 12

som har ett oändligt antal lösningar, men den enklaste är a = b = 1/2 och α = β = 1. Med detta val får vi Runge Kutta metoden av andra ordningen: k 1 =hf(t n, y n ) k 2 =hf(t n + h, y n + k 1 ) y n+1 =y n + (k 1 + k 2 )/2. Ofta används Runge Kutta metoder av högre ordning. Den kändaste är Runge Kutta metoden av fjärde ordningen: k 1 =hf(t n, y n ) k 2 =hf(t n + h 2, y n + 1 2 k 1) k 3 =hf(t n + h 2, y n + 1 2 k 2) k 4 =hf(t n + h, y n + k 3 ) y n+1 =y n + 1 6 (k 1 + 2k 2 + 2k 3 + k 4 ) Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 13

Denna metod behöver fyra f beräkningar 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äng som innehåller namnet på en funktion av formen % f(t,y), där t är ett tal och y en kolumnvektor % yc : en approximativ lösning av y (t) = f(t,y(t)) i t=tc. % fc : f(tc,yc). % h : steglängden. % k : ordningen av Runge-Kutta metoden (1<=k<=4) % Utvariabler: % tn : tc+h, yn är en approximativ lösning i t=tn,och % fn : f(tn,xn). if k==1 k1 = h*fc; yn = yc +k1; elseif k==2 k1 = h*fc; Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 14

k2 = h*feval(fname,tc+(h/2),yc+(k1/2)); yn = yc + (k1+k2)/2; elseif k==3 k1 = h*fc; k2 = h*feval(fname,tc+(h/2),yc+(k1/2)); k3 = h*feval(fname,tc+h,yc-k1+2*k2); yn = yc + (k1 + 4*k2 +k3)/6; elseif k==4 k1 =h*fc; k2 = h*feval(fname,tc+(h/2),yc+(k1/2)); k3 = h*feval(fname,tc+(h/2),yc+(k2/2)); 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å inbyggda Runge Kutta funktioner, ode23 och ode45 (rekommenderas), som kombinerar Runge Kutta metoder av andra och tredje ordningen, resp. fjärde och femte ordningen. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 15

Kapitel 2. Fortran programmering Härefter skall vi övergå till att studera programmering i Fortran, som är det äldsta programmeringsspråket 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. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 16

2.1. Programmeringsspråk Ursprungligen programmerades datorerna på det enda språk de förstod, nämligen binärkod. Som ett exempel på en dylik maskinkod visas nedan ett litet program för en PC-kompatibel dator, som har till uppgift att filtrera bort den åttonde 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ående 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ängst till höger står den motsvarande symboliska instruktionskoden, uttryckt på assembler språket. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 17

Assemblerspråket är maskinberoende, och ursprungligen bara ett sätt att symboliskt uttrycka de maskinkodade instruktionerna (senare infördes bl.a. också makroinstruktioner i de olika assemblerspråken, för att underlätta programmeringen). På grund av att ett program som skrivits på ett assemblerspråk inte kan överföras till en annan dator, och assemblerprogrammen dessutom oftast är långa och invecklade, insåg man redan tidigt vikten av att uppfinna högre programmeringsspråk, som var enklare att använda, och dessutom också möjliggjorde överföring av program mellan olika datorer. Det första av dessa programmeringsspråk var FORTRAN (namnet var en akronym för IBM Mathematical FORmula TRANslation System), som utvecklades av IBM under ledning av John Backus år 1954 för den nya datorn IBM 704, som hade hårdvara för flyttalsberäkningar. Ursprungligen var det meningen att använda språket på bara en dator, men då IBMs kunder fick höra om det, ville alla ha det. FORTRAN-språket är uppbyggt av enkla engelska ord och matematiska termer. För att ett program skrivet på FORTRAN skulle kunna förstås av datorn, måste det översättas till maskinkod, som är det enda språk som datorn kan förstå. För den skull måste 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 året därpå. År 1958 kom IBM ut med en ny förbättrad version av språket, som kallades FORTRAN II, och som kunde användas på IBMs nya datorer (709, 650, 1620 och 7070). Språkets stora framgång ledde till att också andra datortillverkare började skriva FORTRAN-kompilatorer för sina datorer. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 18

Man började snart inse behovet av en allmänt erkänd standard för språket, 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 år 1966 (som ibland kallas FORTRAN 66), och en ny standard, FORTRAN 77, blev godkänd år 1978. Trots alla sina brister (som under årens lopp bättrats på) är FORTRAN fortfarande ett av de populäraste språken för vetenskapliga beräkningar. År 1990 gjordes en uppskattning, enligt vilken 70 % av alla program var skrivna på COBOL ( COmmon Business Oriented Language, det vanligaste språket i affärsvärlden), och ca 60 % av återstoden var skrivna på FORTRAN, resten var skrivna på andra språk. En ny standard, Fortran 90, publicerades i augusti 1991, och har så många utvidgningar och förbättringar, att den i viss mån kan karaktäriseras som ett nytt språk (observera även, att namnet skrivs med små bokstäver). Att Fortran kanhända nu upplever en renässans visas också av att en förbättrad standard, Fortran 2003, har blivit färdig. Bl.a. kritiken mot FORTRAN som programmeringsspråk ledde till att en kommitté, där även John Backus ingick, år 1960 publicerade en beskrivning av ett nytt algoritmiskt språk 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å att man skulle kunna använda detta språk för att beskriva olika räknemetoder. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 19

Algol innehöll både små och stora bokstäver, samt speciella matematiska symboler, såsom + - = > <. Tecknet angav en speciell heltalsdivision, och := betecknade substitution, såsom x := 5. Av någon anledning blev dock inte Algol så populärt som man hade väntat sig, även om det implementerades på många datorer och användes långt in på 1970 talet. Idéerna som låg till grund för Algol blev dock inspirationskälla för andra språk, såsom C och Pascal. Pascal utvecklades av Niklaus Wirth i Zürich år 1971. Språket gavs avsiktligt från början en systematisk och logisk uppbyggnad, så att det skulle vara lättare att skriva bra program. Också en effektiv kompilator (översättningsprogram) planerades. Pascal-kompilatorer introducerades på många datorer, och det inlärdes ofta som första programmeringsspråk. 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 år 1980. Detta språk understöder den moderna objektorienterade programmeringstekniken, och närmar sig också i vissa fall maskinkoden, liksom C. C-språket konstruerades av Dennis Ritchie i AT& T år 1972. Det utvecklades ur ett äldre språk, som kallades BCPL. Detta språk bildade även grunden för en föregångare till C-språket, som kallades B efter första bokstaven i BCPL. C-språket fick sitt namn efter andra bokstaven i BCPL, och definierades i boken The C Programming Language, skriven av Kernigan och Ritchie år 1978. 1990 utkom också en ANSI-standard. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 20

C har en mycket koncis syntax, antagligen beroende på att det utvecklats på datorer med långsamma teletype-terminaler. C är ett mycket effektivt språk, men med C är det också lätt att göra programmeringsfel (som kan vara svåra att finna). Genom objekt-orienterad programmering (OOP) som nu är på modet, har ett antal nya begrepp, såsom klasser, objekt, metoder, etc. introducerats i programmeringen. Det första språket som innehöll sådana begrepp var Simula. C ++, som numera anses vara ett av de populäraste programmeringsspråken utvecklades av Stroustrup, och standardiserades 1997. Där har man försökt kombinera Simulas funktionalitet med C- språkets effektivitet. BASIC (Beginner s All-purpose Symbolic Instruction Code), som utvecklades i Dartmouth College år 1965 av John Kemeny och Thomas Kurtz, är ett språk, som har varit populärt på grund av den låga inlärningströskeln, 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å en gång. Detta gjorde utförandet av programslingor särskilt långsamma. Genom att BASIC alltid förekom på 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å ett högnivåspråk såsom Fortran eller Pascal. Först brukar man specificera problemet, så att man får klart för sig vad programmmet bör göra. Utgående från specifikationen väljer man de metoder och algoritmer som man skall använda i programmet. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 21

Följande steg är att koda (skriva) programmet (i praktiken skrivs programmet in i en fil med hjälp av en editor), varpå det är klart för kompilering (dvs översättning) till maskinkod. Under kompileringen granskas programmets syntax, dvs att man följt språkets regler vid kodningen. Om kompilatorn upptäcker några fel (kompileringsfel), bör dessa rättas innan man kan gå 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åbörjas, uppställer kompilatorn tabeller över symboler som används i programmet och ordnar dem i kategorier. Numera är det också 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å vad programmet skall användas till. Kompilatorer på 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 underlätta programmeringen av massivt parallella datorer har man gjort en utvidgning av Fortran-språket (High Performance Fortran, HPF). När programmet har översatts, skall det länkas, dvs objektfilerna (som innehåller relokerbar kod) kombineras med varandra och eventuellt med yttre biblioteksfiler. Många kompilatorer, särskilt på UNIX-datorer, innehåller en linkoption, som ofta är underförstådd, men på många datorer måste man starta ett särskilt länkningsprogram. Detta kan vara nödvändigt isynnerhet om programmet består av flere moduler. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 22

Tidigare, när datorernas minne ofta var mycket begränsat, kunde länkningsprogrammet också dela upp den exekverbara filen på 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ånga datorer har virtuellt minne, dvs primärminnet innehåller 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årare att hitta än syntaxfelen. Detta skede i programutvecklingen brukar kallas felsökningen (eng. debug ). När man rättat felen, upprepas testningen på nytt, tills inga fel längre visar sig. Då 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årades 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år den slutliga testningen. Detta gör det mycket lättare att skriva stora program. Modulerna kan göras ganska små, de kan t.ex. bestå av en eller ett par subrutiner. Modulär programmering leder till separat kompilering, som numera är möjlig med de flesta kompilatorer. Många UNIX-datorer använder dessutom prekompilatorer, som har till uppgift att behandla särskilda kompilatordirektiv, som finns i programtexten. Introduktion till vetenskapliga beräkningar II, Tom Sundius 2009 23