PDF-format

Indhold
Noter om Maple
KVL, Databehandling forår 2005
Morten Larsen
1 Indledning 1
2 Arbejdsark 2
3 Maples hjælpefunktion 3
4 Indtastning af udtryk 3
5 Forklarende tekster 4
6 Pakker 4
7 Regning med Maple 5
8 Symbolsk beregning, differentiering og integration 7
9 Grænseovergange 8
10 Tildelinger - bundne og ubundne navne 9
11 Funktioner 11
12 Sekvenser, lister og mængder 12
13 Tabeller 15
14 Simplifikation og manipulation af udtryk 16
15 Løsning af ligninger 19
16 Løsning af differentialligninger 22
17 Lidt lineær algebra 23
18 Grafer for funktioner 28
19 Lidt om at arbejde med data 35
20 Oversigt over Maple til husbehov 39
1 Indledning
Disse noter er en indføring i brug af programmet Maple, nærmere bestemt Maple version 9. Noterne introducerer dels
de grundlæggende begreber i Maple og giver anvisning på den basale brug af systemet og dels omhandler de hvordan
man kan bruge Maple til at løse forskellige problemer af matematisk karakter, for eksempel løsning af ligninger,
forsimpling af matematiske udtryk samt tegning af grafer for matematiske funktioner. Det berøres også kortfattet
hvordan man kan benytte Maple til at importere og analysere numeriske data.
1

2
Maple er et computer algebra system, dvs. et system der kan lave algebraisk manipulation. Maple er også et system
til symbolsk beregning, dvs. at det kan regne symbolsk frem for numerisk. Hvad dette faktisk betyder vil fremgå af
det følgende, men først er det nødvendigt med en introduktion til den helt grundlæggende brug af Maple.
2 Arbejdsark
Man udfører sit arbejde i Maple i et arbejdsark (worksheet). I et arbejdsark kan man interaktivt indtaste udtryk og
kommandoer og se resultater og grafer beregnet og tegnet af Maple. Man kan også indføje forklarende tekst enten
som kommentarer til sig selv eller for at forklare andre hvad man gør. Disse noter er således skrevet som et Maple
arbejdsark og kan læses og udføres i Maple.
Når man først starter Maple får man et tomt arbejdsark der kun indeholder en prompt:
>
Prompten markerer starten af en indtastningslinie. Her kan man så indtaste matematiske udtryk og kommandoer
og få Maple til at reagere på det. Når man taster retur (linieskift) på en indtastningslinie behandles linien af en Maple
“kerne” som så udfører hvad man har bedt om, et eventuelt resultat vises derefter under indtastningslinien og Maple
flytter markøren til næste indtastningslinie. Man kan gå tilbage og rette i game indtastningslinier (med piletasterne),
men før man taster retur igen på linien vil den ikke blive behandlet og det gamle resultat vil fortsat stå under indtastningslinien.
At indtastninger behandles af en “kerne” (i ældre versioner af Maple kaldet “server”) betyder ikke at
den bliver sendt til en anden maskine et eller andet sted. Kernen er blot en del af Maple-programmet, men der er god
grund til at skelne mellem “kernen”, der behandler indstatninger, og arbejdsarket, hvor man foretager indtastninger
og får resultater vist. Det der står i arbejdsarket er nemlig ikke nødvendigvis konsistent med tilstanden af kernen,
specielt ikke hvis man henter et eksisterende arbejdsark ind fra en fil - her står alle indtastningslinier tilsyneladende
med resultater som om de har været behandlet af kernen, men det har de ikke! I modsætning til et regneark bliver
arbejdsarkets resultater ikke automatisk opdateret når forudsætningerne for dem ændres. Hvis man således skriver et
udtryk indeholdende x på en indtastningslinie og derefter omdefinerer x vil resultatet af den gamle indtastning ikke
automatisk blive omberegnet og vist; hvis man ønsker en omberegning ud fra den nye værdi af x må man selv flytte
markøren tilbage på indtastningslinien og taste retur. Sekvensen af indtastningslinier og resultater i arbejdsarket er en
“historie” om en konversation med Maple. Med mindre hver indtastningslinie bliver “sendt” til kernen (i den rigtige
rækkefølge) ved for eksempel at taste retur på hver eneste af dem, så er den kun læseren af arbejdsarket, der kender
historien, Maple gør det ikke.
Det er muligt at arbejde med flere arbejdsark samtidig. Man skal her være opmærksom på om arbejdsarkene
benytter den samme underlæggende Maple kerne (hvilket var standard i tidligere versioner af Maple) eller har hver sin
kerne (hvilket er standard fra Maple 9). Tideligere versioner af Maple skal eksplicit startes i “parallel server mode”
(ved at vælge den rigtige start-ikon) for at køre som Maple 9, ellers kører alle ens åbne arbejdsark på samme “server”
(dvs. kerne) og er ikke uafhængige af hinanden. Det vil sige at når man for eksempel definerer x til at være 3 i et af
arkene er x pludselig 3 i alle ark, hvilket kan give en del forvirring hvis man ikke er opmærksom på det. På den anden
side kan det være meget nyttigt hvis man lige vil lave nogle ekstra check-beregninger eller grafer som ikke skal indgå
i ens færdige arbejde. For at få den “gamle” opførsel i Maple 9 skal man gå ind i menuen under “Tools -> Options” og
i det fremkomne vindue vælge fanebaldet “General” og der i kassen “Kernel Mode” vælge “Shared” (hvilket betyder
at arbedsarkene deler den samme Maple kerne).
Et arbejdsark er delt ind i execution groups hvilket vel nærmest må oversættes til “udførelselsgrupper” men som jeg
i det følgende vil betegne beregningsgrupper. Opdelingen i beregningsgrupper er markeret helt til venstre i arbejdsarket
med en firkantet klamme “[”. Normalt vil Maple starte en ny beregningsgruppe for hver ny indtastningslinie. Man kan
samle og dele beregningsgrupper med F4 henholdsvis F3. Alle indtastningslinier i en beregningsgruppe behandles (i
rækkefølge) af Maple serveren når man taster retur på en af dem. Man kan indsætte en ny beregningsgruppe efter
markøren ved at taste Ctrl-J eller før markøren ved at taste Ctrl-K, eller man kan benytte “Insert” menuen for oven og
heruder vælge “Execution group” og hvor den skal indsættes.
Man kan gemme arbejdsark i en fil og hente dem ind igen ved hjælp af “File” menuen. Men husk at når man
henter et arbejdsark ind er der ingen af indtastningslinierne i det der endnu er behandlet af Maple. Man kan få udført
alle indtastningslinierne i et arbejdsark fra en ende af ved at vælge “Edit” menuen for oven og herefter “Execute”
og “Worksheet”. Hvis man gør dette med disse noter får man genopfrisket alle resultaterne men man får også et

hjælpevindue frem på grund af indtastningslinierne i afsnittet om Maples hjælpefunktion neden for, og man får skrevet
en fil “nyfil.txt” på harddisken (hvis man har lov) på grund af en indtastningslinie i afsnittet om at arbejde med data.
Kommandoen restart under dette afsnit står der for at resultaterne vil blive genopfrisket korrekt når man udfører hele
dette arbejdsark i rækkefølge. Hvorfor dette er nødvendigt kan du læse om senere i afnittet om tildelinger.
> restart;
Man kan udskrive et arbejdsark eller eksportere det til HTML til brug på en webside. Disse operationer foretager
man lettest ved at bruge “File” menuen for oven - den ligner noget man er vant til fra alle mulige andre programmer.
3 Maples hjælpefunktion
Maple har en omfattende hjælpefunktion. Faktisk er den elektroniske hjælp den officielle referencemanual for programmet,
der findes ingen trykt manual. Man kan aktivere hjælpefunktionen fra “Help” menuen øverst til højre. Her
har man forskellige muligheder for at komme ind i hjælpesystemet, enten via indholdsfortegnelsen (“Contents”), ved
søgning på emne eller kommando (“Topic”) eller ved fuldtekstsøgning i hjæpen (“Search”). Man har også mulighed
for at springe direkte til hjælp om det ord, markøren står på.
Det er imidlertid også muligt at starte hjælpefunktionen fra en indtastningslinie. For blot at aktivere hjælpefunktionen
så man kan bladre rundt kan man skrive et spørgsmålstegn og taste retur:
> ?
For at få hjælp om et bestemt emne eller en bestemt kommando skriver man navnet efter spørgsmålstegnet. For
eksempel for at få noget at vide om sinusfunktionen:
> ?sin
Under hjælpefunktionen er også guidede “ture” rundt i Maple at finde under punktet “New Users”.
4 Indtastning af udtryk
Der er to måder at indtaste udtryk på i Maple: Standard Math Mode og Maple Notation Mode (i det følgende vil det
engelske “mode” blive oversat til “tilstand”). I standard math tilstand opbygger man udtrykket ved hjælp af “paletter”
hvorfra man kan vælge symboler og underudtryk med musen, samt med indtastning af tal og variabelnavne fra
tastaturet. Efterhånden som udtrykket opbygges vil det have en grafisk form lig den man ville skrive udtrykket med i
hånden. Al denne museklikken er imidlertid langsommelig og en sikker opskrift på at få sig en museskade, så det er
bedre at bruge den anden mulighed når man overhovedet kan: Maple notation. I Maple notation skriver man udtryk
ved hjælp af tastaturet og anvender specielle reserverede ord for at få de matematiske funktioner og symboler man
har brug for. Hvis man så en gang i mellem ikke kan huske hvordan man skriver en given operation kan man ty til
standard math tilstand og paletterne for at opbygge udtrykket og så skifte tilbage til Maple notation for at se hvordan
man skal skrive det (ved at højre-klikke på en indtastningslinie får man en lille menu hvor man blandt andet kan slå
“standard math” til og fra for den linie). Det vil føre for vidt her at beskrive nøjagtig hvordan man opbygger udtryk
i standard math tilstand da det er en interaktiv proces, men det er beskrevet i Maples hjælpefunktion under delemnet
worksheet,expressions,entering (hvis du læser dette i Maple kan du klikke på foregående tekst for at se hjælpen). Det
skal dog nævnes at man under indtastning i standard math tilstand kan skrive Maple notation i indtastningsfeltet for
oven og således få hele deludtryk, som man ved hvordan skal skrives, indsat i det udtryk man er ved at opbygge. Disse
noter benytter kun Maple notation (men hvis du læser dem i Maple står det dig selvfølgelig frit for at skifte frem og
tilbage).
Hvis den prompt man får til at starte med indeholder et spørgsmålstegn så er man i standard math tilstand. Spørgsmålstegnet
er en “pladsholder” der markerer hvor man i øjeblikket er ved at bygge på udtrykket, hvis det er fremhævet,
eller hvor der mangler noget af udtrykket, hvis det ikke er fremhævet. For at skifte fremtidige prompter til Maple notation
skal man gå ind under “Tools -> Options” i menuen for oven og i det fremkomne vindue vælge “I/O display ->
Input display” og herunder “Maple notation”.
3

4
5 Forklarende tekster
Ud over udtryk og kommandoer som skal behandles af Maple er det muligt at skrive forklarende tekster. Disse noter
er for eksempel skrevet som et arbejdsark hvor tekst og indtastningslinier er blandet. Det kan ikke anbefales at skrive
hele afhandlinger i Maple da der mangler en hel del funktionalitet som man finder i et rigtigt tekstbehandlingsprogram
(og Maple 9 iøvrigt bliver meget langsom når der er meget tekst at holde styr på), men det er heller ikke meningen
at man skal skrive lange tekster. Muligheden for at skrive tekst er der for at man kan tilføje kommentarer som gør
det nemmere for en selv og andre at forstå hvilket problem man er i færd med at løse i Maple. En anvendelse kunne
for eksempel være at skrive “Besvarelse til øvelser fra ugeseddel 11” samt sit navn for oven og så “Opgave xx” som
overskrift på hver opgavebesvarelse...
For at skifte fra en indtastningslinie og til tekst taster man Ctrl-T på indtastningslinien. Prompten forsvinder og
værktøjslinien for oven ændres. Man kan nu indtaste en vilkårlig tekst. Der er mulighed for ved hjælp af værktøjslinien
(eller tastaturgenveje) at skifte skrifttype og -størrelse samt for at markere linier som værende for eksempel overskrifter.
Man kan også højre/venstrestille eller centrere tekst. Taster man retur starter man et nyt afsnit men man forbliver i
samme beregningsgruppe (uden beregninger).
Det er faktisk muligt at blande indtastningslinier og tekst nogenlunde frit (i samme beregningsgruppe) men det
giver hurtigt noget rod så denne noteforfatter vil gerne anbefale at man holder tekst for sig og beregninger for sig.
Hvis man gerne vil gruppere tekst sammen med beregninger kan man anvende den facilitet der hedder “sektioner”
(sections) som disse noter benytter sig af. Det fører for vidt her at forklare hvordan man gør men man kan se det i
hjælpen under emnet worksheet,documenting,structuring2.
Det er (selvfølgelig) muligt at få matematiske udtryk som x 2 + y 2 med i sin tekst (uden at få dem behandlet af
Maple - altså blot som tekst). Man skifter til matematikindtastning ved at taste Ctrl-M og skifter tilbage med Ctrl-T.
Indtastning af matematiske udtryk i tekst foregår som på indtastningslinier men starter altid i standard math tilstand.
Man kan for at undgå paletterne indtaste Maple notation i indtastningsfeltet for oven eller skifte til Maple notation ved
at højreklikke på spørgsmålstegnet og slå “Standard Math” fra (man skal dog så slå det til igen når man er færdig for
at indtastningen ikke skal blive stående i Maple notation).
6 Pakker
Maple har et bibliotek af pakker som tilføjer ekstra funktionalitet til programmet (hovedsagelig i form af nye funktioner).
Hver pakke indeholder funktioner inden for et bestemt område, for eksempel grafer, forsimpling af udtryk eller
lineær algebra. Man kan indlæse alle funktioner fra en pakke ved at indtaste kommandoen with som følger:
> with(plots):
\QTR{_cstyle10}{Warning, the name changecoords has been redefined}\QTR{_cstyle10}{
}
Dette indlæser funktionerne fra pakken “plots”. Hvis man angiver et semikolon i stedet for et kolon i slutningen
af linien får man en liste over alle de funktionsnavne, der bliver defineret; ellers får man som her kun eventuelle
advarsler.
Man kan bruge en enkelt funktion fra en pakke uden at læse pakken ind ved at skrive funktionens “fulde navn”,
for eksempel for at anvende funktionen ZeroMatrix fra pakken LinearAlgebra:
> LinearAlgebra[ZeroMatrix](2,2); 0 0
0 0
Indlæste pakker forsvinder når man bruger kommandoen restart (se også afnittet om tildelinger)
> restart;

7 Regning med Maple
Maple kan bruges som en regnemaskine hvis man skulle have brug for det. Man indtaster et regneudtryk afsluttet
med semikolon (;) og taster retur hvorpå Maple spytter resultatet ud. Maple kan selvfølgelig klare de fire almindelige
regnearter:
> 12+6;
> 12-6;
> 12*6;
> 12/6;
Man kan også nemt potensopløfte:
> 2^3;
18
6
72
2
8
I modsætning til for eksempel Excel foretrækker Maple at regne eksakt. Det vil for eksempel sige at dividerer man
1 med 3 får man 1 3 og ikke en unøjagtig decimal-repræsentation som for eksempel 0.33333333. Tilsvarende: hvis
man tager eksponentialfuktionen af 1 får man e, symbolet for den naturlige logaritmes grundtal, og ikke for eksempel
2.7182818:
> 1/3;
> exp(1);
1
3
e
I virkeligheden regner Maple ikke på udtryk, Maple forsimpler udtryk. Hvis ens udtryk som de foregående udelukkende
indeholder (eksakte) tal, simple regneoperationer og kendte funktioner så består forsimplingen blot i at samle
talkonstanten i udtrykket til en simplere (men stadig eksakt) talkonstant, eventuelt ved at udføre regneoperationerne
og tage funktionsværdierne hvis det kan gøres eksakt. Hvis en konstant ikke kan forsimples yderligere lader Maple
den være:
> sin(Pi/4);
> sin(Pi/4)^2;
> sin(1+Pi/4);
1 √
2
2
1
2
sin(1 + 1
4 π)
At Maple rent faktisk forsimpler et udtryk som 1/3 og giver den simpleste nøjagtige repræsentation kan man
forsikre sig om ved for eksempel at indtaste (5-2)/(2+7):
> (5-2)/(2+7);
1
3
Her kan man iøvrigt også se at man kan bruge parenteser som man forventer i et udtryk til at afgrænse underudtryk
og få den korrekte evalueringsrækkefølge. Ovenstående uden parenteser evalueres efter de sædvanlige regler for
regneudtryk:
> 5-2/2+7;
11
Hvis man regner med decimaltal i Maple går programmet ud fra at man per definition regner med “unøjagtige”
værdier og så begynder programmet rent faktisk at regne. Et enkelt decimaltal i et udtryk “forurener” udtrykket og
bevirker at Maple regner den del af udtrykket med decimaltal. For eksempel:
> 1.0/3;
5

6
> 1.0/3*3;
> exp(1.0);
0.3333333333
0.9999999999
2.718281828
At “forureningen” nogen gange ikke breder sig til hele udtrykket kan der også gives et eksempel på:
> Pi/4.0;
0.2500000000 π
Man kan tvinge Maple til at give et decimaltal som resultat ved at benytte funktionen evalf:
> evalf(1/3);
> evalf(exp(1));
> evalf(Pi/4.0);
0.3333333333
2.718281828
0.7853981635
Man kan give evalf besked på at udregne resultatet med mere end de 10 betydende cifre som er standard, for
eksempel 200 cifre:
> evalf(exp(1),200);
2.7182818284590452353602874713526624977572470936999595749669676277\
24076630353547594571382178525166427427466391932003059921817\
41359662904357290033429526059563073813232862794349076323382\
98807531952510190
Det er faktisk kun maskinens hukommelse og ens egen tålmodighed der sætter grænser for hvor mange cifre man
kan få resultatet med og 500000 decimaler er ikke urealistisk for en moderne PC.
Lige som man i Maple kan regne med vilkårligt mange decimaler kan man også regne med vilkårligt store heltal:
> 37^45;
37074694665532807170105663883978228276095096806613832327136970789\
759157
(for at få at vide hvor mange cifre der er i dette resultat kan man bruge funktionen length:)
> length(37^45);
71
De vilkårligt mange betydende cifre i numeriske resultater samt de vilkårligt store heltal er noget der adskiller
Maple fra programpakker til rent numerisk matematik som for eksempel Matlab, og naturligvis også fra gængse
kontorprogrammer som for eksempel Excel.
Man kan også have brug for at referere til resutatet af den foregående beregning. I Maple betyder et procent-tegn
(%) der indgår i et udtryk at her skal resultatet af forrige beregning indsættes:
> 1/3;
> 1+%;
> %+1/%;
1
3
4
3
25
12
Man kan tilsvarende bruge dobbelt procent-tegn (%%) for at få fat i resultatet af beregningen før den foregående
og tredobbelt procenttegn (%%%) for at få fat i det tredieseneste resultat (men så kan man heller ikke komme længere
tilbage):
> %%-%%%;

1
Man skal dog være varsom når man bruger procent-tegnene idet ’%’ refererer til den senest udregnede resultat,
hvilket ikke nødvendigvis er det samme som det resultat der står umiddelbat oven for den aktuelle indtastningslinie.
Den seneste beregning er den der stammer fra den seneste indtastningslinie, der blev sendt til Maple “kernen”, altså
den seneste indtastningslinie, man tastede retur på. Det giver anledning til forvirring når man går tilbage og retter i
tidligere indtastede linier i arbejdsarket idet procent-tegn i disse linier ikke refererer til det, man tror.
Hvis du læser disse noter i Maple kan du taste retur på nedenstående indtastningslinie nogle gange i træk og se
hvorledes resultatet ændrer sig:
> %+%;
2
8 Symbolsk beregning, differentiering og integration
Nu er det de færreste der blot benytter Maple som simpel regnemaskine. Styrken ved Maple er at man kan foretage
symbolsk beregning eller måske rettere kan få Maple til at foretage algebraisk manipulation af symbolske udtryk. Et
simpelt eksempel:
> 3*(x+1)-x;
2 x + 3
Her formår Maple altså at forsimple udtrykket indeholdende den ukendte størrelse x. Maple kan også finde ud af
at integrere og differentiere:
> int(2*x+3,x);
x 2 + 3 x
Til int funktionen angiver man først udtrykket, der skal integreres, og derefter den variabel man integrerer over.
Tilsvarende for diff funktionen, der foretager differentiering:
> diff(%,x);
2 x + 3
Husk at procent-tegnet “%” betyder “resultatet af sidst udregnede udtryk”, i dette tilfælde x 2 + 3 x, så ovenfor
kontrollerer vi at differentiering ophæver integration.
Maple kender naturligvis de almindelige regler for integrations- og differentieringsregler og kan finde ud af at
differentiere og integrere kendte funktioner:
> int(1/x,x);
> diff(sin(x),x);
ln(x)
cos(x)
Man kan også få differentieret og integreret ukendte funktioner, men så er det selvfølgelig nødt til at være rent
symbolsk:
> diff(f(x),x);
> int(f(x),x);
> diff(%,x);
d
dx f(x)
f(x) dx
f(x)
Man kan også explicit bede om en rent symbolsk differentiering eller integration for at forhindre at Maple anvender
sine indbyggede regler. For at gøre dette skriver man Int og Diff med stort begyndelsesbogstav:
> Int(1/x,x);
1
x dx
> Diff(sin(x),x);
7

8
d
dx sin(x)
Man kan bruge funktionen value for at bede Maple om at udregne (forsimple) et sådant udtryk:
> value(%);
cos(x)
Nu kan vi kontrollere om vi fra vores matematik kan huske regler for differentiering af produktet af to funktioner,
forholdet mellem to funktioner eller sammensætningen af to funktioner:
> diff(f(x)*g(x),x);
> diff(f(x)/g(x),x);
> diff(f(g(x)),x);
( d
d
dx f(x)) g(x) + f(x) ( dx g(x))
d
dx f(x)
g(x)
− f(x) ( d
dx g(x))
g(x) 2
D( f )(g(x)) ( d
dx g(x))
Bemærk i dette resultat at “D” er differential-operatoren, så D(f) betyder “f differentieret”. Funktionssammensætningen
f(g(x)) kunne også have været skrevet (f@g)(x):
> (f@g)(x);
9 Grænseovergange
f(g(x))
Med Maple kan man tage grænseværdier med funktionen limit:
> limit((1-x^2)/(1-x),x=1);
2
> limit(sin(x)/x,x=0);
1
For grænseovergange hvor værdien afhænger af om man går mod grænsen fra venstre eller fra højre skal man
specificere hvilken vej man vil lave overgangen ved at give et ekstra argument til limit. Det ekstra argument skal være
et af ordene “left” eller “right”. Først et eksempel på hvad maple gør hvis man glemmer at specificere om man tager
grænseværdien fra højre eller venstre:
> limit(tan(x),x=Pi/2);
undefined
Og her så den rigtige måde at gøre det på:
> limit(tan(x),x=Pi/2,left);
∞
> limit(tan(x),x=Pi/2,right);
−∞
Med limit kan man også tage grænser i ∞ eller −∞:
> limit(exp(-x),x=infinity);
> limit(x^2,x=-infinity);
∞
Der findes en rent symbolsk (“forsinket”) version af limit som hedder Limit (analogt med Diff og Int).
> Limit(1/x,x=infinity);
> value(%);
0
1
lim
x→∞ x
0
Maple kan selv finde ud af at tage grænseværdier når man integrerer mod ∞ for eksempel i følgende uegentlige
integral:

Int(exp(-x^2),x=-infinity..infinity);
> value(%);
∞
e (−x2 ) dx
−∞
√ π
10 Tildelinger - bundne og ubundne navne
Som det fremgår af ovenstående to afsnit kan Maple regne symbolsk med ukendte størrelser som x, f, og g. Man kan
imidlertid tildele en værdi til et navn, eller binde et navn til en værdi. Et ubundet navn står blot for sig selv og indgår
i beregninger som en ukendt størrelse. Oven for regnede vi med ubundne navne og Maple lavede derfor algebraiske
manipulationer på selve navnene. Hvis vi derimod binder et navn til en værdi vil Maple erstatte navnet med dets værdi
hvor det indgår i senere udtryk. For eksempel:
> x:=3;
Dette tildeler værdien 3 til x (eller binder x til 3).
> x;
> 3*(x+1)-x;
x := 3
3
9
Vi kan binde et navn ikke bare til en simpel (tal)værdi men til et udtryk (3 er jo også et udtryk). Vi kan for eksempel
lave en ny binding for x:
> x:=y+2;
> 3*(x+1)-x;
x := y + 2
2 y + 7
Hvis vi nu tildeler y en værdi ændres værdien af x også:
> y:=5*z;
> x;
y := 5 z
5 z + 2
Det vil sige, egentlig er værdien af x ikke ændret, den er fortsat y + 2, men når x optræder i et udtryk erstattes det
med y + 2 og y erstattes derefter med sin værdi. Man kan verificere dette ved at tildele en ny værdi til y:
> y:=7;
> x;
y := 7
9
For at ophæve bindingen for x og gøre navnet ubundet igen kan man skrive følgende “tildeling”:
> x:=’x’;
x := x
Man tildeler her navnet x sig selv som værdi. Man skriver ’x’ på højresiden for at angive at der er tale om selve
navnet x og ikke dets aktuelle værdi (tildelingen x:=x ville blot tildele x den aktuelle værdi af x dvs. værdien af y + 2
og x ville dermed med den nuværende binding af y så få værdien 9). Når man omslutter et udtryk med apostroffer,
altså skriver ’udtryk’, beder man Maple om at lade være med at evaluere udtrykket (det eneste Maple gør er at fjerne
apostrofferne og eventuelt forsimple udtrykket).
Vi kan verificere at x igen er ubundet:
> x;
x
I stedet for at skrive den noget kryptiske tildeling x:=’x’ kan man bruge kommandoen unassign:
9

10
> x:=3;
> x;
> unassign(’x’);
> x;
x := 3
3
x
Endelig kan man få Maple til at glemme alle bindinger og gå tilbage til en tilstand der ligner den hvor man lige
har startet programmet. Dette gøres med kommandoen restart.
> x:=3;
x := 3
> x;
3
> restart;
> x;
x
Kommandoen restart vil forekomme flere gange i det følgende i slutningen af et afsnit for at fjerne alle bindinger
der laves i afsnittet (noterne kan jo udføres som et arbejdsark i Maple). Kommandoen står også som noget af det første
i starten af noterne. Dette er dels for at man kan læse afsnittene uafhængigt af hinanden uden at skulle gå ud fra at der
kan være foretaget bindinger og dels for at man kan udføre hele dette arbejdsark med “Edit -> Execute -> Worksheet”
menupunktet og få de samme resultater hver gang. Hvis du ikke læser disse noter i Maple er dette ikke relevant for
dig, men nu ved du i det mindste hvorfor der står restart rundt omkring.
Det er i det hele taget en god ide altid at starte sine arbejdsark med en restart kommando da man så kan læse
arbejdsarket ind og udføre det uden at eventuelle bindinger man tidligere har lavet under samme kørsel af Maple
forstyrrer resultatet.
Man skal vare sig for at komme til at lave en rekursiv tildeling som for eksempel x:=x+1 eller det mere subtile
x:=y sammen med y:=’x’. En sådan tildeling får Maple til at gå i uendelig løkke når man prøver at evaluere udtryk
med de rekursivt bundne navne.
Da man kan binde navne til hele udtryk kan man med fordel navngive de udtryk man regner med at bruge igen.
For eksempel:
> udtryk:=2*x+3;
> 2*udtryk;
> intudtryk:=int(udtryk,x);
> diff(intudtryk,x);
> x:=3;
> udtryk;
> restart;
udtryk := 2 x + 3
4 x + 6
intudtryk := x 2 + 3 x
2 x + 3
x := 3
Navne kan man vælge forholdsvis frit. De skal bare:
1) starte med et bogstav,
2) kun indeholde bogstaver, cifre og ’_’ samt
3) ikke være reserverede ord (som for eksempel sin, cos og diff).
9

11 Funktioner
Det er muligt at evaluere et udtryk indeholdende ukendte størrelser som x for givne værdier af de ukendte ved hjælp
af funktionen eval:
> udtryk:=sin(x)^2;
> eval(udtryk,x=0);
> eval(udtryk,x=Pi/4);
udtryk := sin(x) 2
0
1
2
Men ofte har man brug for at definere en (navngiven) funktion. En navngiven funktion defineres med notationen
navn := parametre -> funktionsudtryk
Man kan så tage værdier af funktionem med den sædvanlige notation navn(parameterværdier).
> f:=x->sin(x)^2;
> f(Pi/4);
Man kan differentiere og integrere:
> diff(f(x),x);
Og funktionssammensætte:
> g:=x->2*x;
> (f@g)(x);
> (g@f)(y);
> (g@f)(Pi/4);
Man kan også definere funktioner af flere variable:
> d:=(x,y)->sqrt(x^2+y^2);
> d(3,4);
f := x → sin(x) 2
1
2
2 sin(x) cos(x)
g := x → 2 x
sin(2 x) 2
2 sin(y) 2
1
d := (x, y) → x 2 + y 2
5
Ofte har man brug for at konvertere et udtryk til en funktion. Den helt naive måde at gøre dette på går ikke i
Maple:.
> udtryk;
> h:=x->udtryk;
sin(x) 2
h := x → udtryk
Dette er forkert! Det ser måske umiddelbart meget tilforladeligt ud, men man bliver skuffet hvis man forsøger at
anvende h:
> h(Pi/4);
sin(x) 2
Problemet er at Maple ikke ekspanderer navnet udtryk når funktionen defineres og dermed bliver h en funktion der
for alle x giver navnet udtryk, der ved evaluering erstattes af den værdi, udtryk er bundet til. At denne værdi indeholder
11

12
et x spiller ingen rolle, for det er det ubundne navn x og ikke funktionsparameteren x. Sagt på en anden måde forbindes
det x der står for funktionens parameter aldrig med det x der forekommer “inde i” udtryk.
For korrekt at definere en funktion ud fra et udtryk skal man bruge funktionen unapply:
> h:=unapply(udtryk,x);
> h(Pi/4);
h := x → sin(x) 2
1
2
Parametrene til unapply er dels det udtryk der skal være funktionsudtryk og dels navnet på den ukendte i udtrykket
der skal være parameter i funktionen (eller flere navne hvis der skal være flere parametre).
> restart;
12 Sekvenser, lister og mængder
En vigtig struktur i Maple er sekvenser af udtryk. En sekvens fremkommer for eksempel som det vil blive vist senere
når man beder Maple om at løse en ligning der har flere løsninger; Maple giver løsningerne som en sekvens. En liste
er en anden vigtig struktur i Maple. Lister bruges mange steder, for eksempel hvor det er nødvendigt at give flere
værdier på en enkelt værdis plads i en af Maples indbyggede kommandoer (som for eksempel array kommandoen der
bruges i afsnittet om tabeller). En tredie vigtig struktur i Maple er en mængde, der svarer nogenlunde til en mændge
i matematik men også ofte anvendes i stedet for lister til at slå flere værdier sammen på en enkelt værdis plads i en
kommando. De tre strukturer er beslægtede og gennemgås derfor her samlet.
Man skriver en sekvens som en række udtryk adskilt af kommaer. Man kan skrive en sekvens på højre side af en
tildeling:
> sekvens:=x,1,2*x+3,diff(h(x),x),x;
sekvens := x, 1, 2 x + 3, d
dx h(x), x
Som det ses kan en sekvens indeholde alle mulige slags udtryk. Rækkefølgen af udtrykkene i sekvensen bevares
og det er muligt for det samme udtryk at indgå flere gange (gentagelser bevares).
En liste skrives som en sekvens omsluttet af kantede parenteser:
> liste1:=[a,b,c,d];
liste1 := [a, b, c, d]
> liste2:=[sekvens];
liste2 := [x, 1, 2 x + 3, d
dx h(x), x]
Ligesom sekvenser bevarer lister rækkefølgen af elementerne samt eventuelle gentagelser.
En mængde skrives som en sekvens omsluttet af krøllede parenteser (mængdeparenteser):
> mængde1:={a,b,1,2};
> mængde2:={sekvens};
mængde1 := {1, 2, a, b}
mængde2 := {1, 2 x + 3, x, d
dx h(x)}
Elementernes rækkefølge bevares ikke nødvendigvis og som det fremgår fjernes gentagelser. Dette svarer til mængdebegrebet
i matematik (hvor et element enten er med eller ikke, og hvor der ikke er nogen specificeret rækkefølge af
elementerne). Maples sekvenser og lister ikke har nogen direkte pendant i matematikken.
Man kan tage et enkelt element ud af en sekvens med indeks-operatoren sekvens[indeks]:
> sekvens[2];
1
Hvis man angiver et interval som indeks får man den tilsvarende delsekvens:
> sekvens[2..4];

1, 2 x + 3, d
dx h(x)
Tilsvarende er det muligt i en liste at indeksere sig frem til enkelte elementer eller dellister:
> liste1[3];
> liste1[1..2];
c
[a, b]
Indeksering kan også anvendes på mængder, men da rækkefølgen af elementer ikke bevares har elementerne altså
ikke nødvendigvis den samme plads som da man tastede mængden ind:
> mængde1[2];
> mængde1[3..4];
2
{a, b}
Man kan få antallet af elementer i en liste eller mængde med funktionen nops samt få en sekvens af elementerne
med funktionen op:
> nops(liste1);
> nops(mængde2);
> op(liste1);
> op(mængde2);
4
4
a, b, c, d
1, 2 x + 3, x, d
dx h(x)
Ved at angive et indeks (enkelt eller interval) som første argument til op kan man nøjes med at udtage et enkelt
element eller en delsekvens:
> op(2..3,liste1);
b, c
De to funktioners navne kræver en forklaring. Navnet nops står for “number of operands” og navnet op står for
“operand(s)”. Det er fordi de to funktioner faktisk opererer på alle slags udtryk og anvendes af Maple til at tælle
henholdsvis uddrage deludtryk med. For eksempel:
> udtryk:=3*x^2-10*x+1;
> nops(udtryk);
> op(udtryk);
> op(2,udtryk);
udtryk := 3 x 2 − 10 x + 1
3
3 x 2 , −10 x, 1
−10 x
Operanderne i et liste- eller mængdeudtryk er simpelt hen listens eller mængdens elementer, så derfor kan de to
funktioner bruges med lister til at tælle og udtage elementer (det sidste kan man nu også gøre med et indeks). Bortset
fra anvendelse med lister og mængder kan man altså bruge de to funktioner til at udtage deludtryk til videre beregning,
for eksempel hvis man ønsker at forsimple et enkelt led i et større udtryk. Ud over dette har man nok kun brug for de
to funktioner hvis man ligefrem programmerer i Maple.
Man kan anvende de sædvanlige operationer på mængder så som foreningsmængde (union), fællesmængde (intersection)
og mængdedifferens:
> {1,2,3} union {3,4,5};
{1, 2, 3, 4, 5}
> {1,2,3} intersect {3,4,5};
{3}
13

14
> {1,2,3} minus {3,4,5};
{1, 2}
Det er muligt at undersøge om et givent element er med i en mængde eller en liste med member funktionen:
> member(2,mængde1);
true
> member(3,mængde1);
> member(2*x+3,liste2);
false
true
Operatoren in er den sædvanlige “er element i” operator:
> 2 in mængde1;
2 in {1, 2, a, b}
For rent faktisk at evaluere dette til sandt eller falsk (som med member) skal man bruge funktionen evalb (“evaluate
boolean”):
> evalb(%);
true
Med mængder kan man iøvrigt se at heltal og decimaltal er to forskellige ting for Maple. Således kan både 2 og
2.0 være indeholdt i samme mængde mens en mængde der indeholder 3 ikke af den grund indeholder 3.0:
> mængde3 := {1,2,3,2.0};
> member(2.0,mængde3);
> member(3.0,mængde3);
mængde3 := {1, 2, 3, 2.0}
true
false
Man kan få genereret en sekvens med funktionen seq. For eksempel kan dannes en sekvens af x 2 for værdier a x
mellem 5 og 20 således:
> seq(x^2,x=5..20);
25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400
På denne måde kan man danne sekvenser af udtryk på basis af heltallene i et givet interval (og ved at angive kantede
eller krøllede parenteser uden om kaldet af seq kan man lave det til en liste henholdsvis en mængde). I stedet for et
interval kan man angive en liste, mængde eller sekvens som så vil blive anvendt elementvis til at danne sekvensen:
> seq(x^2,x=mængde1);
1, 4, a 2 , b 2
Denne anvendelse af seq kan ligne det man kan gøre med funktionen map beskrevet i det følgende, de væsentligste
forskelle er at seq altid danner en sekvens mens map danner en mængde hvis anvendt på en mængde og en liste hvis
anvendt på en liste, samt at seq danner værdier ved at bruge et givent udtryk som skabelon mens map danner værdier
ved at anvende en funktion.
Med fuktionen map kan man få anvendt en vilkårlig funktion elementvis på alle elementerne i en mængde (eller i
en liste, tabel eller anden Maple datastruktur der indeholder flere elementer):
> map(sqrt,{1,2,3,4,5});
{1, 2, √ 2, √ 3, √ 5}
Man behøver ikke at anvende en indbygget funktion som sqrt, man kan bruge en funktion man selv har defineret:
> f:=x->x+1;
f := x → x + 1
> map(f,{1,2,3,4,5});
{2, 3, 4, 5, 6}
Faktisk kan man definere den funktion der skal anvendes direkte i kaldet af map:
> map(x->1/x,{1,2,3,4,5});

{1, 1
2
, 1
3
1 1
, ,
4 5 }
En anden nyttig funktion er select, der udvælger elementer fra en liste eller mængde ud fra en funktion der anvendt
på et element giver sandt (elementet medtages) eller falsk (elementet medtages ikke), altså en funktion hvis krop er et
logisk udtryk. For eksempel:
> select(x->x>2 and x select(x->123 mod x = 0,[seq(n,n=2..122)]);
[3, 41]
Bemærk at sekvensen dannet med seq laves om til en liste simpelt hen ved at pakke den ind i kantede parenteser.
Moduludoperatoren a mod b giver resten ved division af a med b (altså resten af 123 delt med x i dette tilfælde, og når
den er nul går x op i 123).
Såvel map som select anvender eventuelle argumenter ud over de to første som ektra argumenter til den funktion
der skal evalueres (hvis den tager mere end et enkelt argument):
> map((x,y)->y^x,{1,2,3,4},10);
{10, 100, 1000, 10000}
> restart;
13 Tabeller
En fjerde vigtig struktur er tabeller (arrays). Tabeller er en slags udvidelse af lister til flere dimensioner og med
vilkårlige heltalsintervaller som indekser. Man kan tænke på en liste som en en-dimensionel tabel med indeks gående
fra 1 til antallet af elementer (dog kan man ikke ændre det enkelte element i en liste hvilket man kan med en tabel).
En tabel konstrueres med array funktionen. De(t) første argument(er) til array er de(t) interval(ler), man vil benytte
som indeks og det sidste argument er en liste af de elementer der skal gemmes i tabellen fra start (den kan udelades).
> tabel1:=array(1..4,[a,b,c,d]);
tabel1 := [a, b, c, d]
> tabel1[2];
b
I modsætning til hvad man kan med lister kan man ikke udtage en deltabel ved at indeksere en tabel med et interval.
Til gengæld kan man ændre det enkelte element i en tabel:
> tabel1[3]:=f;
tabel13 := f
For at se indholdet af en tabel er man nødt til at anvende funktionen print da Maple ikke automatisk ekspanderer
tabeller når de indgår i udtryk (dette er meget praktisk hvis man arbejder med store tabeller).
> tabel1;
> print(tabel1);
tabel1
[a, b, f, d]
Man kan som sagt definere tabeller i flere dinemsioner:
> tabel2:=array(1..3,1..3,[[1,2,3],[4,5,6],[7,8,9]]);
> tabel2[2,3];
⎡
tabel2 := ⎣
6
1 2 3
4 5 6
7 8 9
⎤
⎦
15

16
Bemærk hvordan tabellens elementer blev givet som en liste af lister, hvor den yderste liste svarer til første dimension/indeks
(her rækker), det næste niveau af lister til anden dimension/indeks (her søjler), og så videre hvis der havde
været flere dimensioner. Det er igen muligt at ændre det enkelte element:
> tabel2[1,1]:=100;
> print(tabel2);
tabel21, 1 := 100
⎡
100
⎣ 4
2
5
⎤
3
6 ⎦
7 8 9
Todimensionelle tabeller anvendes i Maples linalg pakke til at repræsentere matricer men anvendes ikke i .LinearAlgebra
pakken som er den, der beskrives i afsnittet om lineær algebra
Maple understøtter en anden slags tabel, nemlig en associativt indekseret tabel (som i Maple kaldes “table” hvor
den almindelige tabel kaldes “array”). Forskellen til den almindelige tabel er at indeks ikke længere behøver at være
et heltal, det kan være et hvilket som helst objekt. Det kan være nyttigt når man skal knytte egenskaber til en samling
af objekter. Her blot et lege-eksempel (der igen illustrerer at heltal og decimaltal er forskellige i Maple):
> assoc:=table([12=heltal,12.0=decimaltal,x=navn,2*x+3=udtryk]);
> assoc[12];
> assoc[12.0];
> assoc[2*x+3];
> restart;
assoc := table([12 = heltal, 12.0 = decimaltal, 2 x + 3 = udtryk, x = navn])
heltal
decimaltal
udtryk
14 Simplifikation og manipulation af udtryk
Det er ikke alle simplifikationer af et indtastet udtryk som Maple foretager automatisk. For eksempel:
> x*((x+2)^2-17)+x^2+7;
x ((x + 2) 2 − 17) + x 2 + 7
Her ville man jo nok synes at udtrykket kunne forsimples ved at gange ind i parenteserne og samle led med samme
potens af x. Man kan imidlertid bede Maple om at forsøge at forsimple et udtryk med funktionen simplify:
> simplify(%);
x 3 + 5 x 2 − 13 x + 7
Dette synes man jo nok er en simplere form. Med simplify kan man forsimple en lang række udtryk, men da det
ikke er veldefineret hvad der er den “simpleste form” af et matematisk udtryk kommer man ofte ud for at et udtryk
man synes kunne have en simplere form ikke ændres af simplify. Så er der en række funktioner der giver en mulighed
for mere explicit at specificere hvordan man vil have udtrykket ændret. Det kunne for eksempel være at ovenstående
polynomium ville være simplere i faktoriseret form, det vil sige som et produkt af polynomier af mindst mulig grad.
Kommandoen factor forsøger at faktorisere et udtryk til et produkt af simplere udtryk:
> factor(%);
(x + 7) (x − 1) 2
Dette synes også at være en simpel form, og simplify gør da helle ikke noget ved dette udtryk
> simplify(%);
(x + 7) (x − 1) 2
Her har vi altså et eksempel på et udtryk der har to former som simplify så at sige synes lige godt om.
Det modsatte af at faktorisere et udtryk er at ekspandere det ved at gange alle parenteser ud. Dette gør man med
funktionen expand:

expand(%);
x 3 + 5 x 2 − 13 x + 7
Vi kunne også have brugt expand direkte på det oprindelige udtryk hvis vi vidste at det var denne form af polynomiet
vi foretrak:
> expand(x*((x+2)^2-17)+x^2+7);
x 3 + 5 x 2 − 13 x + 7
... og tilsvarende kunne vi have brugt factor direkte på det oprindelige udtryk:
> factor(x*((x+2)^2-17)+x^2+7);
(x + 7) (x − 1) 2
Kommandoerne expand og factor kan også anvendes på andet end simple polynomier og ofte virker de modsat af
hinanden:
> (x+1)/(x-2);
> expand(%);
> factor(%);
x + 1
x − 2
x 1
+
x − 2 x − 2
x + 1
x − 2
Med expand kan man også få expanderet udtryk med trigonometriske funktioner efter diverse kendte transformationer:
> sin(2*x);
> expand(%);
sin(2 x)
2 sin(x) cos(x)
Her kan man ikke bruge factor for at komme tilbage:
> factor(%);
2 sin(x) cos(x)
Man skal i stedet bruge funktionen combine som ofte gør det modsatte af expand for specielle funktioner:
> combine(%);
> expand(sin(x+y));
> combine(%);
> Int(x+x^2,x);
> expand(%);
> combine(%);
sin(2 x)
sin(x) cos(y) + cos(x) sin(y)
sin(x + y)
x + x 2 dx
x dx +
x + x 2 dx
Man kan bede expand om at ikke at ekspandere et bestemt underudtryk. Ved sædvanlig brug af expand ekspanderes
alle underudtryk:
> expand((x+1)*(y+z));
x 2 dx
x y + x z + y + z
17

18
Men hvis man som ekstra argument til funktionen angiver et underudtryk vil dette ikke blive ekspanderet:
> expand((x+1)*(y+z),x+1);
(x + 1) y + (x + 1) z
Med funktionen Combine fra pakken SolveTools kan man forsimple udtryk med logaritmer, eksponentialfunktioner
og potenser som den normale combine ikke klarer:
> combine(ln(a)+ln(b));
ln(a) + ln(b)
> SolveTools[Combine](ln(a)+ln(b));
ln(a b)
I polynomier i flere variable (eller i det hele taget i blandede udtryk med flere variable) er det ofte nyttigt at samle
koefficienterne for en bestemt variabel. Betragt for eksempel følgende blandede polynomium i x, y, og z:
> x+3*x+5*x*y+y+x*z;
4 x + 5 x y + y + x z
Med funktionen collect kan vi få samlet for eksempel y’erne:
> collect(%,y);
Vi kunne også samle x’erne:
> collect(%,x);
(5 x + 1) y + 4 x + x z
(5 y + 4 + z) x + y
Hvis man i stedet for navnet på en enkelt variabel angiver en liste af variabelnavne vil collect først samle koefficienterne
for den første variabel og derefter inden for hver koefficient samle koefficienter for den anden variabel, og så
videre:
> collect(%,[y,x]);
(5 x + 1) y + (4 + z) x
Med collect kan man også samle koefficienterne distribueret, det vil sige samle koefficienter for produkter af de
angivne variable i stedet for at samle for en enkel variabel af gangen. Dette opnår man ved at give ordet “distributed”
som et tredie argument til funktionen (og så kan man angive variabelnavnene som en mængde fordi rækkefølgen ikke
længere har nogen betydning):
> collect(%,{x,y},distributed);
(4 + z) x + 5 x y + y
Maple sorterer ikke automatisk leddene i et polynomium efter potensernes størrelse. Faktisk beholder Maple den
rækkefølge man taster polynomiet ind i:
> x^2+4*x^3-2+10*x;
x 2 + 4 x 3 − 2 + 10 x
For at få et polynomium ordnet efter potenserne (som i sædvanlig notation) skal man bruge funktionen sort:
> sort(%);
4 x 3 + x 2 + 10 x − 2
Sortering af et polynomium er “destruktiv” på den måde at den huskes af Maple og næste gang det samme polynomium
forekommer vil det have den nye orden af leddene. Hvis for eksempel polynomiet fra før indtastes i samme
rækkefølge som oven for får man det altså nu i den sorterede version:
> x^2+4*x^3-2+10*x;
4 x 3 + x 2 + 10 x − 2
For blandede polynomier kan man angive hvilke variable der skal sorteres på:
> y^3+y^2*x^2+x^3;
> sort(%,[x,y]);
y 3 + y 2 x 2 + x 3
x 2 y 2 + x 3 + y 3

Hvis man som tredie argument til sort angiver det specielle ord “plex” får man polynomiet sorteret i ren leksikografisk
orden efter variablene (i den rækkefølge man angiver dem) således leddene sorteres først efter potensen af
den først angivne variabel, dernæst efter potensen af den næste angivne variabel og så videre. Hvis man ikke angiver
“plex” får man leddene sorteret efter den totale potens af de variable som oven for.
> sort(%,[x,y],plex);
x 3 + x 2 y 2 + y 3
En sidste funktion til manipulation af udtryk som skal nævnes her er normal. Den konverterer et rationelt udtryk
til faktoriseret normal form hvilket betyder at udtrykket er en brøk hvor tæller og nævner er polynomier der ikke er
delelige med hinanden.
> 1/x+x/(x+1);
> normal(%);
1 x
+
x x + 1
x + 1 + x 2
x (x + 1)
Som standard ekspanderes tælleren mens nævneren er faktoriseret. Man kan angive at både tæller og nævner skal
ekspanderes ved at give det specielle ord “expanded” som andet argument.
> normal(%,expanded);
15 Løsning af ligninger
x + 1 + x 2
x + x 2
En ligning i Maple er simpelt hen et udtryk hvor der forekommer et lighedtegn (“=”, ikke at forveksle med en tildeling
som skrives “:=”).
> 2*x=4;
2 x = 4
Maple kan løse ligninger algebraisk med funktionen solve. Man angiver en ligning og den variabel man ønsker at
løse for:
x:
> solve(%,x);
> solve(y=a*x,x);
y
a
Hvis man angiver variablen der skal løses for i en mængde får man løsningen ud på en lidt anden måde:
> solve(y=a*x,{x});
2
{x = y
a }
Denne form af løsningen er velegnet hvis man vil bruge den i en funktion som eval til at substituere en værdi for
> eval(x^2,%);
y 2
a 2
Hvis en ligning har mere end én løsning forsøger Maple at finde dem alle. Resultatet af solve bliver da en sekvens
af løsninger. For eksempel for den generelle andengradsligning a x 2 + b x + c = 0:
> solve(a*x^2+b*x+c=0,{x});
{x = 1 −b +
2
√ b2 − 4 a c
}, {x =
a
1 −b −
2
√ b2 − 4 a c
}
a
Disse løsninger turde være velkendte... Vi gemmer løsningerne ved at binde dem til navnet løs (for løsning(er)):
> løs:=%;
19

20
løs := {x = 1 −b +
2
√ b2 − 4 a c
}, {x =
a
1 −b −
2
√ b2 − 4 a c
}
a
For at få en enkelt løsning ud af en sekvens af løsninger må vi indeksere i sekvensen:
> løs[1];
> løs[2];
{x = 1
2
−b + √ b2 − 4 a c
}
a
{x = 1 −b −
2
√ b2 − 4 a c
}
a
Med vores generelle løsning på andengradsligingen kan vi nu bruge eval til at få løsninger til forskellige andengradsligninger:
> eval(løs,{a=2,b=-3,c=1});
> eval(løs,{a=2,b=4,c=2});
{x = 1}, {x = 1
2 }
{x = −1}, {x = −1}
Vi kunne selvfølgerlig også får løsningerne til denne andengradsligning ved at bruge solve direkte:
> solve(2*x^2+4*x+2=0,{x});
{x = −1}, {x = −1}
For ligninger af mere end fjerde grad findes der ikke nogen generel løsning og Maple vil derfor ofte give løsninger
i form af RootOf funktionen. Det betyder “løsningerne du leder efter er rødder i polynomiet inde i RootOf”. Maple
indfører selv en hjælpevariabel i polynomiet, den vil som regel hedde _Z, _Z1 eller lignende (alle variable som Maple
indfører starter med et understregningstegn “_”).
Følgende sjettegradsligning har dels en løsning som Maple finder algebraisk og dels fem løsninger som er rødder
i et femtegradspolynomium:
> løs:=solve({4*x^6-12*x^5+2*x^2-9*x+9=0},{x});
løs := {x = 3}, {x = RootOf(4 _Z 5 + 2 _Z − 3, index = 1)},
{x = RootOf(4 _Z 5 + 2 _Z − 3, index = 2)},
{x = RootOf(4 _Z 5 + 2 _Z − 3, index = 3)},
{x = RootOf(4 _Z 5 + 2 _Z − 3, index = 4)},
{x = RootOf(4 _Z 5 + 2 _Z − 3, index = 5)}
For at få numeriske løsninger ud skal vi så bruge evalf:
> evalf(løs);
{x = 3.}, {x = 0.8086092632}, {x = 0.3993814688 + 0.8387514991 I},
{x = −0.8036861004 + 0.6548567008 I}, {x = −0.8036861004 − 0.6548567008 I},
{x = 0.3993814688 − 0.8387514991 I}
Her fik vi atså fire imaginære rødder og en enkelt reel rod ud over roden x=3 som solve fandt algebraisk.
Man bør altid checke sine løsninger ved at substituere tilbage ind i den oprindelige ligning. Dette kan man gøre
med eval.
> lign:=3*x-4=0;
> løs:=solve(lign,{x});
> eval(lign,løs);
lign := 3 x − 4 = 0
løs := {x = 4
3 }
0 = 0
Med solve kan man også løse ligningssystemer. Man angiver et ligningssystem som en mængde af ligninger:

lign:={u+v+w=1, 3*u+v=3, u-2*v-w=0};
lign := {u + v + w = 1, 3 u + v = 3, u − 2 v − w = 0}
> løs:=solve(lign,{u,v,w});
løs := {v = 3 −2 4
, w = , u =
5 5 5 }
Vi kan igen bruge eval til at checke vores løsning:
> eval(lign,løs);
{0 = 0, 3 = 3, 1 = 1}
Man kan også med fordel bruge eval til at få en enkelt variabel “pakket ud” ud af løsningsmængden:
> eval(u,løs);
Man kan også bruge solve til at løse uligheder:
4
5
> solve(x^2+4>8,x);
RealRange(−∞, Open(−2)), RealRange(Open(2), ∞)
Ovenstående er Maples måde at skrive de to intervaller [ −∞,-2[ og ]2, ∞] på. Hvis vi beder om at få løsningen på
den alternative form ved at pakke x ind i en mængde får vi løsningen som to uligheder hvilket er noget mere læseligt:
> solve(x^2+4>8,{x});
{x < −2}, {2 < x}
Maple kan også løse systemer der indeholder uligheder. Løsningerne som solve finder opfylder alle ligninger og
uligheder i det system man angiver:
> solve({x^2-9=0,x>0},{x});
{x = 3}
Hvis Maple ikke kan finde en løsning får man ikke noget resultat.
> solve({x4},{x});
Hvor Maple ikke kan løse ligningen algebraisk giver solve en RootOf løsning :
> solve(x^3=cos(10*x),x);
1
10 RootOf(−1000 cos(_Z) + _Z3 , label = _L2)
Vi kan igen få en konkrete løsning ud af RootOf løsningen med evalf:
> evalf(%);
0.1566948942
Men med evalf får vi kun en enkelt løsning ud, selv om der måtte være flere (i dette tilfælde er der syv, hvilket
man kan forvisse sig om ved at tegne graferne for de to funktioner med plot, se afnittet om grafer for funktioner).
Maple kan løse visse ligninger med periodiske funktioner hvor perioderne er indbyrdes lineære:
> solve(sin(x)=cos(3*x),x);
− 1 3
π,
4 4
> solve(sin(x)=cos(1+x),x);
1
5
π, π, −7 π, −3 π,
8 8 8 8 π
cos(1)
arctan(
1 + sin(1) )
Nogle gange må Maple imidlertid helt give op og i disse tilfælde giver solve ikke nogen løsning, selv om der skulle
være en:
> solve(sin(x)=cos(x^2),x);
Når man ikke kan finde løsninger algebraisk med solve kan man forsøge at finde dem numerisk med fsolve:
> fsolve(sin(x)=cos(x^2),x);
0.8493688624
21

22
Maple forsøger med fsolve at finde alle reelle løsninger hvis ligningen er et polynomium. Tag for eksempel sjettegradsligningen
fra før:
> fsolve({4*x^6-12*x^5+2*x^2-9*x+9=0},{x});
{x = 0.8086092632}, {x = 3.}
Her findes de to reelle løsninger. Man kan bede fsolve om også at lede efter imaginære løsninger:
> fsolve({4*x^6-12*x^5+2*x^2-9*x+9=0},{x},complex);
{x = −0.8036861004 − 0.6548567008 I}, {x = −0.8036861004 + 0.6548567008 I},
{x = 0.3993814688 − 0.8387514991 I}, {x = 0.3993814688 + 0.8387514991 I},
{x = 0.8086092632}, {x = 3.}
For ligninger der ikke er polynomier finder fsolve kun en enkelt løsning, selv når der er flere:
> fsolve(cos(x)=0,x);
1.570796327
Man kan bede fsolve om at lede efter løsningen i et bestemt interval:
> fsolve(cos(x)=0,x=Pi..2*Pi);
4.712388980
Man kan også bede fsolve om at undgå visse værdier:
> fsolve(cos(x)=0,x,avoid={x=Pi/2,x=3*Pi/2});
−1.570796327
Endelig kan man benytte et trick hvor man dividerer den oprindelige ligning med de(n) løsning(er) man allerede
har fundet. Dette giver singulariteter i ligningen som fsolve så undgår:
> x1:=fsolve(cos(x)=0,x);
x1 := 1.570796327
> x2:=fsolve(cos(x)/(x-x1)=0,x);
x2 := −1.570796327
> fsolve(cos(x)/(x-x1)/(x-x2)=0,x);
−266650.5305
Som det kan ses giver det dog ikke nødvendigvis nogen særlig god kontrol af hvor den næste løsning findes.
Det samme trick med at dividere med kendte løsninger kan man ikke bruge med solve:
> solve(cos(x)=0,x);
> solve(cos(x)/(x-Pi/2)=0,x);
(Dette giver ingen løsninger.)
1
2 π
En sidste speciel form for løsning af ligninger skal nævnes. Det hænder at man ønsker at finde konstanter der får
en ligning til at være sand for alle værdier af den variable. Man kan bruge solve sammen med den specielle funktion
identity til at løse problemer af denne type:
> solve(identity(sin(x)=cos(a*x+b),x),{a,b});
{b = − 1
1
π, a = 1}, {b = π, a = −1}
2 2
Her finder vi de værdier af a og b som gør ligningen sin(x) = cos(a x + b) sand for alle værdier af x.
> restart;
16 Løsning af differentialligninger
Maple kan løse såvel ordinære som partielle differentialligninger samt systemer af differentialligninger. Her vil kun
løsning af ordinære differentialligninger blive kortfattet gennemgået, hvis man har brug for at løse partielle differentialligninger
med Maple kan man se hvordan det gøres i online-hjælpen (funktionen hedder pdsolve).

Vi kan løse en differentialligning med begyndelsesbetingelse og få en partikulær løsning. Ligning og begyndelsesbetingelser
skal gives som en mængde til funktionen dsolve og vi pakker dem derfor ind i mænder med det samme.
Først selve ligningen:
> lign:={diff(y(t),t,t)+5*diff(y(t),t)+6*y(t)=0};
Så begyndelsesbetingelserne:
> bb:={y(0)=0,D(y)(0)=1};
lign := {( d2
dt 2 y(t)) + 5 ( d dt y(t)) + 6 y(t) = 0}
bb := {y(0) = 0, D(y)(0) = 1}
Bemærk at vi her bruger differential-operatoren D til at angive differentieringen af y. Det er for besværligt at bruge
diff fordi vi så også er nødt til at bruge unapply for at lave resultatet om til en funktion som vi kan tage værdien af i 0.
Med differential-operatoren får vi direkte lavet en funktion af én variabel om til dens afledte funktion.
Vi bruger fællesmængde-operatoren union til at slå de to mængder sammen i kaldet af dsolve:
> løs:=dsolve(lign union bb,y(t));
løs := y(t) = e (−2 t) − e (−3 t)
Bemærk at dsolve skal have de(n) funktion(er) vi søger en løsning for som andet argument.
For at få løsningen lavet om til en funktion vi kan tage værdier af pakker vi den først ud af løsningsmængden med
eval.
> eval(y(t),løs);
e (−2 t) − e (−3 t)
I dette tilfælde hvor løs blot er en enkelt ligning kan man også udtage højresiden med funktionen rhs (“right hand
side”, tilsvarende findes en lhs), men at bruge eval er mere generelt.
> rhs(løs);
e (−2 t) − e (−3 t)
Derefter laver vi udtrykket om til en funktion af t med unapply:
> y1:=unapply(%,t);
y1 := t → e (−2 t) − e (−3 t)
Nu kan vi verificere at vores fundne løsning, funktionen y1, virkelig er en løsning til ligningen:
> eval(lign,y=y1);
{0 = 0}
Tilsvarende kan vi kontrollere at ligningen opfylder begyndelsesbetingelserne:
> eval(bb,y=y1);
{0 = 0, 1 = 1}
I stedet for en partikulær løsning kan vi få den fuldstændige løsning ved at udelade begyndelsesbetingelserne:
> løs:=dsolve(lign,y(t));
løs := {y(t) = _C1 e (−2 t) + _C2 e (−3 t) }
Maple genererer automatisk de nødvendige konstanter (her _C1 og _C2) som hører til den fuldstændige løsning.
Vi kan igen bruge eval til at verificere den fundne løsning:
> eval(lign,løs);
> restart;
17 Lidt lineær algebra
{0 = 0}
I dette afsnit vil nogle af Maples faciliteter inden for lineær algebra blive gennemgået. Der mange flere funktioner i
Maple til at løse problemer inden for lineær algebra end der er mulighed for at gennemgå her, brug online-hjælpen for
at finde ud af mere.
23

24
Der er i Maple to forskellige pakker til lineær algebra: Den ene hedder linalg og den anden hedder LinearAlgebra.
De to pakker er alternativer til hinanden og indeholder for en stor del funktioner, der gør det samme men hedder noget
forskelligt. LinearAlgebra er den nyeste af de to og generelt den mest behagelige at bruge, så det er den der vil blive
anvendt i det følgende. Hvis man vil lave abstrakt lineær algebra kan man dog overveje at bruge linalg i stedet.
Så først indlæser vi altså pakken LinearAlgebra:
> with(LinearAlgebra):
Nu er der en række funktioner til rådighed til at danne matricer og vektorer og til at regne med dem. Men først og
fremmest kan man skrive små matricer og vektorer direkte med en speciel notation som følger:
> A:=;
> b:=;
A :=
1 2
1 3
1
b :=
−2
I denne notation skrives søjler adskilt af lodrette streger og rækker adskilt af kommaer . Det er ikke altid den
lodrette streg er markeret på et dansk PC-tastatur, man får fat i den ved at holde “Alt Gr” tasten nede og trykke på den
apostrof-tast, der sidder to pladser til højre for tasten med tallet 0 (skråt til højre over “Å”).
Man kan selv vælge om man vil skrive matricer i søjleorden eller rækkeorden:
> ;
> ;
1 2
3 4
1 3
2 4
Vi så søjlevektoren b defineret oven for, og som man måske kan regne ud kan man skrive en rækkevektor som
følger:
> ;
Man kan også anvende funktionerne Matrix og Vector:
> B:=Matrix([[1,1],[-2,1]]);
> Vector([1,2]);
B :=
[1, 2]
1 1
−2 1
1
2
Her angives elementerne som (lister af) lister. Det er specielt nyttigt hvis man indlæser data fra en fil med funktionen
readdata, se afsnittet om at arbejde med (importerede) data.
Der er talrige andre måder at lave matricer på med Matrix, her er blot nogle få eksempler (se i hjælpen under
“Matrix”). Først og fremmest kan man angive dimensionerne af matricen og så en funktion fra søjle- og rækkenummer
til værdi:
> Matrix(2,2,(r,s)->r/s);
⎡
⎣ 1
1
2
⎤
⎦
2 1
Man kan også bare angive dimensionerne og en værdi der skal stå på alle pladser:
> Matrix(2,2,7);

Man kan angiver en diagonalmatrix:
7 7
7 7
> Matrix([1,2],scan=diagonal);
1
0
0 2
> Matrix(2,x->x^2,shape=diagonal);
1
0
0 4
> Matrix(2,shape=identity);
En enhedsmatrix kan man også få med:
> IdentityMatrix(2);
1 0
0 1
1 0
0 1
Hvis en matrix eller vektor er for stor til at blive vist på skærmen får man i stedet en pladsholder som beskriver
hvad der burde stå som resultat:
> Matrix(100,x->x,shape=diagonal);
100 x 100 Matrix Data Type : anything Storage : diagonal Shape : diagonal Order : Fortran_order
Man kan så dobbeltklikke på pladsholderen for at åbne et vindue hvor man kan inspicere og/eller rette i matricens
elementer (man kan selvfølgelig gøre det samme for matricer der er små nok til at blive vist). Man har i browseren
mulighed for at se en farvekodet oversigt over for eksempel tætheden i matricen og for at zoom’e ind og ud; det fører
for vidt her at beskrive alle mulighederne.
Addition og subtraktion af matricer fungerer som forventet:
> A+B;
> A-B;
2 3
−1 4
0 1
3 2
Matrixmultiplikation skrives med et punktum i stedet for det sædvanlige multiplikationstegn:
> A.B;
> A.b;
Potensopløftning fungerer som forventet:
> A^2;
Man kan også multiplicere med en skalar:
> 7*A;
−3 3
−5 4
−3
−5
3 8
4 11
7 14
7 21
25

26
Hvis man adderer eller subtraherer en skalar svarer det til at addere eller subtrahere med en enhedsmatrix multipliceret
med skalaren, det vil sige at skalaren bliver lagt til alle diagonalelementerne:
> 7+A;
8 2
1 10
Hvis man adderer en matrix med et ubundet navn gør Maple umiddelbart ikke noget (og hvordan skulle Maple
egentlig vide om navnet står for en skalar eller noget andet?):
> x+A;
1 2
x +
1 3
I mondsænign hertil, hvis man multiplicerer en matrix med et ubundet navn får man det multipliceret ind i matricen
elementvis:
> x*A;
x 2 x
x 3 x
Hvis man gerne vil gennemtvinge den elementvise addition eller multiplikation kan man bruge funktionerne Add
eller Multiply:
> Add(x,A);
> Multiply(x,A);
Man kan invertere på to måder:
> 1/A;
> MatrixInverse(A);
Man kan finde determinanten:
> Determinant(A);
1 + x 2
1 3 + x
x 2 x
x 3 x
3 −2
−1 1
3 −2
−1 1
Funktionen map kan bruges til at få anvendt en funktion på alle elementer i en matrix:
> map(sqrt,A);
1
√
1 2
1 √
3
Man behøver som vi så i afsnittet om sekvenser, lister og mængder ikke at anvende en indbygget funktion som
sqrt, man kan anvende en funktion man selv har defineret.
Man kan udtage enkelte elementer eller delmatricer:
> A[2,2];
> A[2,1..2];
3
[1, 3]
Vi kan bruge funktionen LinearSolve til at løse matrixligninger. For at løse ligningen A x = b for en matrix A og
vektorer x og b bruger man LinearSolve som følger:
> LinearSolve(A,b);

7
−3
Man kunne også have løst ligningen direkte ved at premultiplicere b med A inverteret:
> (1/A).b;
7
−3
Vi kan benytte LinearSolve til at løse matrixligningen A X = B for matricer A, X, og B:
> LinearSolve(A,B);
7
1
−3 0
Også her kunne vi have løst ligningen direkte:
> (1/A).B;
7
1
−3 0
Der er imidlertid tilfælde hvor den direkte løsningsmetode ikke slår til: Når matricen A er singulær (og altså ikke
kan inverteres):
> A:=;
> b:=;
> (1/A).b;
A :=
b :=
5 7
0 0
\QTR{_cstyle17}{Error, (in rtable/Power) singular matrix}\QTR{_cstyle17}{
}
Ligningen har uendelig mange løsninger. I sådan et tilfælde giver LinearSolve en parameteriseret løsning:
> LinearSolve(A,b);
⎡
⎣
3
0
3 7
−
5 5 _t02
_t02
Maple indfører selv den nødvendige parameter. For LinearSolve er Maples valg af parameternavn lidt mere “besværlig”
end vi har set tidligere idet parameteren nummereres med et indeks. Ovenstående parameter _t02 er man
nødt til at skrive _t0[2] når man skal referere til den.
Til slut vil vi verificere den generelle løsning samt en bestemt løsning for _t02 = −6:
> løs:=%;
> A.løs=b;
> eval(løs,_t0[2]=-6);
> A.%=b;
⎡
løs := ⎣
3
0
3
0
⎤
⎦
3 7
−
5 5 _t02
=
9
−6
=
Man kan finde mindste kvadraters løsninger til overbestemte ligningssystemer (altså hvor man har flere ligninger
en variable) med funktionen LeastSquares, for eksempel:
_t02
3
0
3
0
⎤
⎦
27

28
> A:=; b:=;
⎡ ⎤
1 2
A := ⎣ 1 3 ⎦
2 5
⎡ ⎤
1
b := ⎣ −2 ⎦
2
> løs:=LeastSquares(A,b);
8
løs :=
−3
Vi kan få fejlens størrelse i de enkelte ligninger som følger:
> A.løs-b;
Vi skulle måske lige vise at LinearAlgebra også kan regne med andet end tal i matrixelementerne:
⎡
⎣
> A:=; b:=; løs:=LinearSolve(A,b); eval(løs,a=1);
a 2
A :=
1 3
b :=
1
−2
⎡
7
⎤
⎢
løs := ⎢ 3 a − 2
⎣ 2 a + 1
−
3 a − 2
7
−3
⎥
⎦
> restart;
18 Grafer for funktioner
1
1
−1
I dette afsnit vil nogle af mulighederne for at lave grafer i Maple blive illustreret. For en mere fuldstændig beskrivelse
af de enkelte funktioner og især af de mange varianter man har muligheder for at angive med specielle koder henvises
til Maples hjælpefunktion. Da grafer fylder meget vil noteforfatteren af hensyn til at holde sidetallet nede i flere af de
følgende eksempler forsøge at vise flere faciliteter på en gang.
For det første skal det nævnes at man blot ved at højreklikke på resultatet af en beregning hvis resultat er et udtryk
får en menu frem hvorfra det er muligt at få lavet en graf af den funktion udtrykket repræsenterer. For det andet er
det i vid udtsrækning muligt at tilpasse sine grafer ved at højreklikke på dem og bruge den fremkomne menu. Alle
tilpasninger kan man også få ved at angive specielle koder i selve kaldet af funktionen der tegner grafen. Denne tilgang
er en fordel hvis man gerne vil have den samme tilrettede graf hver gang man udfører arbejdsarket og ikke ønsker at
starte forfra i menuerne hver gang. Da der er myriader af specielle koder til at vælge skrifttyper, farver, koordinatakser
og så videre kan de ikke alle beskrives her, så som nævnt oven for henvises til online-hjælpen.
Den basale funktion til at få tegnet en 2D graf hedder plot. Man kan kalde den simpelt hen med en funktion af én
variabel og et interval funktionen skal tegners for:
> plot(sin,0..2*Pi);
⎤
⎦

–0.5
1
0.5
0
–1
1 2 3 4 5 6
Man kan også angive et udtryk og så angive variabelnavnet hvor man angiver intervallet:
> plot(sin(x)*cos(x^2),x=0..2*Pi);
–0.5
1
0.5
0
–1
1 2 3 4 5 6
Man kan naturligvis også få tegnet funktioner man selv definerer. Og man kan få tegnet flere funktioner i samme
graf ved at angive en liste af funktioner (eller som her: udtryk) der skal tegnes:
> f:=x->x^3-4*x^2+7;
f := x → x 3 − 4 x 2 + 7
> plot([f(x),diff(f(x),x),int(f(x),x)],x=-3..6);
x
29

30
80
60
40
20
–2 0
2 4 6
–20
–40
Maple vælger automatisk at tegne graferne for funktionerne i forskellige farver (hvilke farver kan man bestemme
ved at angive en speciel kode til plot).
Maple kan håndtere at tegne grafer med en x-akse der går til uendeligt. Aksen bliver da som det fremgår af
nedenstående eksempel komprimeret (ikke lineært naturligvis). Med samme eksempel vil det blive vist hvordan man
får en titel på sin graf.
> plot(sin(x)/x,x=-infinity..infinity,title="Graf for sin(x)/x");
Graf for sin(x)/x
0
-infinity infinity
Maple kan ikke som standard håntere grafer for funktioner med singulariteter særlig godt. Tangens funktionen for
eksempel har værdier gående mod både ∞ og −∞ ved π 2 + n π for heltallige n. Hvis man bare forsøger at tegne
funktionen ser det ikke særlig godt ud:
> plot(tan,0..2*Pi);
x
x

0
–500
–1000
–1500
1 2 3 4 5 6
Det første man kan gøre er at begrænse intervallet på y-aksen ved at give endnu et argument til plot:
> plot(tan,0..2*Pi,-4..4);
4
3
2
1
0
–1
–2
–3
–4
1 2 3 4 5 6
Men Maple tegner stadig (næsten) lodrette streger i singulariteterne fordi plot som udgangspunkt går ud fra at
funktionen der tegnes er kontinuert. Ved at angive den specielle kode “discont=true” til plot kan man gøre opmærksom
på at funktionen der skal tegnes ikke er kontinuert:
> plot(tan,0..2*Pi,-4..4,discont=true);
31

32
4
3
2
1
0
–1
–2
–3
–4
1 2 3 4 5 6
Det er muligt at lave parametriske grafer, det vil sige grafer hvor y ikke er en funktion af x men hvor sammenhængende
værdier af x og y udtrykkes ved en parameter t. En parametrisk graf får man ved at give plot en liste med tre
elementer: Et parametrisk udtryk for x, et parametrisk udtryk for y og et interval for parameteren.
> plot([cos(t)/t,2*sin(t)/t,t=1..15]);
1.5
1
0.5
–0.2 0
0.2 0.4
Som man kan se af ovenstående graf samt en del af de foregående eksempler så er skalaen på de to akser ikke
nødvendigvis den samme. Hvis det er vigtigt at skalaen er den samme (for eksempel så man kan måle afstande direkte
i grafen) så kan man give plot funktionen den specielle kode “scaling=constrained”:
> plot([cos(t)/t,2*sin(t)/t,t=1..15],scaling=constrained);

1.5
0.5
1
–0.2 0 0.2 0.4
Maple kan også lave tredimensionelle grafer af funktioner af to variable. Til dette benytter man funktionen plot3d
som i sin brug ligner plot på mange måder (bortset fra at der er en ekstra akse at angive intervaller for).
Her et eksempel hvor plot3d anvendes med et udtryk:
> plot3d(sin(x)*cos(y),x=0..2*Pi,y=0..2*Pi);
Og neden for et eksempel hvor plot3d anvendes med en funktion:
> g:=(x,y)->sin(x)*sqrt(y);
g := (x, y) → sin(x) √ y
> plot3d(g,0..2*Pi,0..10,axes=boxed,labels=["sin","sqrt","combo"]);
33

34
combo
3
2
1
0
–1
–2
–3
0
2
4
sqrt
6
8
Som standard vises 3D grafer uden akser men det er muligt at angive at man ønsker en bestemt type akser ved at
give specielle koder til plot3d, som for eksempel oven for hvor koden “axes=boxed” bevirker at akserne tegnes som
en kasse uden om den tegnede overflade. Koden “labels=[...]” angiver hvilke betegnelser man ønsker på akserne (og
kan udelades hvis man ikke ønsker betegnelser på).
Det er analogt med 2D grafer muligt at lave parametriske 3D grafer. Syntaksen er en lille smule anderledes for
3D end for 2D idet parameterintervallerne i plot3d angives uden for (efter) listen af de tre parametriske udstryk for
koordinaterne (mens parameterintervallet angives inden i listen når man bruger plot).
> plot3d([s*sin(s)*cos(t),s*cos(s)*cos(t),s*sin(t)],s=0..2*Pi,t=0..Pi);
Der er utallige andre muligheder for at lave specielle grafer også i andre koordinater end de kartesiske: polære koordinater
i 2D og sfæriske eller cylindriske koordinater i 3D. Eller man kan for eksempel lave grafer med logaritmiske
akser. Brug hjælpefunktionen til at finde ud af mere.
En enkelt interessant speciel type af grafer skal nævnes her uden at der dog vil blive givet eksempler: Animerede
grafer. Det er muligt med de to funktioner animate og animate3d at få vist animerede grafer, altså grafer med en ekstra
dimension der vises som en animation over tid. Da papir er et temmelig utaknemmeligt medie at vise animationer på
10
6
5
4
3
sin
2
1
0

er det ikke muligt at beskrive det på nogen fornuftig måde i disse noter, men slå de to funktioner op i hjælpefunktionen
og lav nogle eksperimenter!
> restart;
19 Lidt om at arbejde med data
Man kan selvfølgelig indlæse (importere) og behandle numeriske data i Maple, for eksempel forsøgsdata man skal analysere
eller bare have tegnet en fornuftig graf for (regnearksprogrammer er ofte ikke så gode til at lave videnskabelige
grafer). Man kan også eksportere sine resultater igen.
For at man kan importere data fra en fil skal filen være i mellemrums- eller tabulatorsepareret tekstformat. Decimaltal
skal angives med decimalpunktum (og ikke komma). Stort set alle programmer der har med tal at gøre kan
eksportere i et sådant format. Lad os nu antage at filen “minfil.txt´´ indeholder følgende:
1.2 3.4 5.6
3 6 9
4.5 6.7 8.9
9 6 3
Der er 4 linier med 3 tal i hver. Dette kan indlæses simpelt med:
> data:=readdata("minfil.txt",3);
data := [[1.2, 3.4, 5.6], [3., 6., 9.], [4.5, 6.7, 8.9], [9., 6., 3.]]
Man er nødt til at angive antallet af kolonner, ellers indlæses kun en enkelt kolonne. Bemærk at resultatet af
indlæsningen er en liste af lister, hvor hver af de indre lister svarer til en linie i filen. Dette format kan hvis man ønsker
det direkte konverteres til en matrix med Matrix funktionen (se afsnittet om lineær algebra).
Hvis tekstfilen, der skal indlæses, indeholder andet end kommatal (for eksempel bogstavkoder i visse kolonner)
er man nødt til mere detaljeret at angive formatet af kolonnerne, ellers kløjes Maple i det. Se i hjælpen for readdata
for at se de mange muligheder, her skal blot nævnes at man i stedet for antallet af kolonner kan angive en liste med
kolonnernes datatyper, for eksempel:
> readdata("minfil.txt",[string,float,integer]);
[[“1.2”, 3.4, 5], [“3”, 6., 9], [“4.5”, 6.7, 8], [“9”, 6., 3]]
Noget af det man typisk er interesseret i at tegne grafer for data. Antag at hver af de tre kolloner svarer til en målt
egenskab og man vil vise alle sine målinger i et 3D punkt-plot:
> with(plots):
Warning, the name changecoords has been redefined
> pointplot3d(data,view=[0..10,0..10,0..10],scaling=constrained,axes=bo
> xed,symbol=circle,labels=["x","y","z"],orientation=[-100,70],color=bla
> ck);
35

36
z
10
8
6
4
2
10
8
6
y
4
2
0 2 4 6 8 10
0
x
Man kan også få punkterne forbundet med liniestykker i stedet. Hvis man ønsker både liniestykker og tydelig
markering af punkterne kan det laves som to separate pointplot3d plots og kombineres med display3d:
> p1:=pointplot3d(data,symbol=circle,color=black):
> p2:=pointplot3d(data,style=line,color=red):
> display3d(p1,p2,view=[0..10,0..10,0..10],scaling=constrained,axes=box
> ed,labels=["x","y","z"],orientation=[-100,70]);
z
10
8
6
4
2
10
8
6
y
4
2
0 2 4 6 8 10
0
x
Det var selvfølgelig også muligt at man ville vise bare den anden kolonne mod den første:
> data12:=data[1..4,1..2];
data12 := [[1.2, 3.4], [3., 6.], [4.5, 6.7], [9., 6.]]
> pointplot(data12,symbol=cross,scaling=constrained,view=[0..10,0..10],
> labels=["x","y"]);

y
10
8
6
4
2
0
2 4 6 8 10
Hvis man på tilsvarende måde vil vise tredie kolonne mod første må man være lidt mere snedig og bruge map for
at generere den ønskede liste af talpar:
> data13:=map(r->[r[1],r[3]],data);
data13 := [[1.2, 5.6], [3., 9.], [4.5, 8.9], [9., 3.]]
Det kan jo også være at man ønsker at transformere lidt på værdierne og for eksempel lave et enkeltlogaritmisk
plot:
> pointplot(map(r->[log[10](r[1]),r[2]],data13),style=line,labels=["log
> (x)","z"]);
9
8
7
z 6
5
4
3
0.2 0.4 0.6 0.8
x
log(x)
Ofte ønsker man at tilpasse en kurve så den går igennem (eller tæt på) ens datapunkter. Dette kan man gøre med
pakken CurveFitting. Med denne pakke kan man for eksempel lave lineær regression, tilpasse polynomier eller tilpasse
med stykkevis polynomielle kurver (splines).
> with(CurveFitting):
Som eksempel vil brugen af funktionen LeastSquares fra pakken CurveFitting blive beskrevet. Denne er ikke at
forveksle med funktionen af samme navn fra pakken LinearAlgebra (som jo bruges til at finde mindste kvadraters
37

38
løsninger til overbestemte ligningssystemer).
Hvis man bare skriver
> LeastSquares(data13,x);
8.812137559 − 0.494268374915711906 x
får man den linie, der bedst (i mindste kvadraters betydning) beskriver datapunkterne. Nu er en linie næppe nogen
god interpolation af disse datapunkter, det kunne tænkes at et andengradspolynomium ville være bedre. Man kan til
LeastSquares angive hvilken form den funktion, man ønsker at tilpasse med, skal have. Funktionen skal være lineær i
sine parametre, men ikke nødvendigvis lineær i funktionsvariablen. Så vi kan forsøge med et andengradspolynomium:
> kurve1:=LeastSquares(data13,x,curve=a*x^2+b*x+b);
kurve1 := 2.833792084 − 0.313247450643479031 x 2 + 2.83379208407862526 x
Et alternativ kunne være et andengradspolynomium i logaritmen til x i stedet:
> kurve2:=LeastSquares(data13,x,curve=a*log(x)^2+b*log(x)+c);
kurve2 := 3.775907628 + 10.5396548308231992 ln(x) − 4.93559635161722721 ln(x) 2
Vi kan tegne de to kurver sammen med de oprindelige punkter for at sammenligne interpolationerne:
> display(pointplot(data13,symbol=circle),plot([kurve1,kurve2],x=1..10)
> );
8
6
4
2
0
2 4 6 8 10
Som det sidste i dette afsnit skal kort nævnes hvordan man får sine data eksporteret som en tabulatorsepareret
tekstfil. Det gør man med funktionen writedata, der er fuldstændig analog med readdata, inklusiv muligheder der er
for at angive kolonneformat (kommatal er standard):
> writedata("nyfil.txt",data13);
> restart;
x

20 Oversigt over Maple til husbehov
Denne oversigt er i PDF udgaven af disse noter (som du læser nu) tilrettet fra Maple arbejdsarket for at få en klarere
opstilling. I Maple kan man ikke opstille tekst i tabeller og kolonner og oversigten kommer dermed til at se noget
mindre overskuelig ud.
For en beskrivelse af funktioner til at løse matematiske problemer så som at forsimple udtryk, løse ligninger et
cetera henvises til de relevante afsnit i noterne.
Maple Indtastning:
indtastning; Udfør det indtastede, vis resultatet
indtastning: Udfør det indtastede, vis ikke resultatet
Ctrl-T Skift til indtastning af tekst
Ctrl-M Indtast matematisk udtryk i tekst
Ctrl-J Indsæt en ny beregningsgruppe efter denne
Ctrl-K Indsæt en ny beregnningsgruppe før denne
?emne Slå et emne op i online hjælpen
Hent tidligere resultater:
% Seneste resultat
%% Næstseneste resultat
%%% Tredieseneste resultat
Bindinger og pakker:
navn:=udtryk Bind navn til værdien af udtryk
unassign(’navn’) Gør navn ubundet igen
with(pakke) Indlæs pakke
restart Fjern alle bindinger og indlæste pakker
Almindelig regning:
x+y Addition
x-y Subtraktion
x*y Multiplikation
x/y Division
xˆy Potensopløftning
evalf(udtryk) Tilnærm værdien af et udtryk med decimaltal
evalf(udtryk,n) Det samme, men med n decimalers præcision
Trigonometriske funktioner:
sin Sinus
cos Cosinus
tan Tangens
cot Cotangens
arcsin Arcus sinus
arccos Arcus cosinus
arctan Arcus tangens
arccot Arcus cotangens
Pi Konstanten π
Andre almindelige funktioner:
sqrt Kvadratroden
exp Eksponentialfunktionen
ln Den naturlige logaritme
log Også den naturlige logaritme
log[a] Logaritmen med grundtal a
39

40
Brugerdefinerede funktioner:
x->udtryk Unavngiven funktion af variablen x
(x,y)->udtryk Unavngiven funktion af flere variable
f :=x->udtryk Definer funktionen f af variablen x
g:=(x,y)->udtryk Definer funktionen g af flere variable
unapply(udtryk,x) Lav et udtryk hvor x indgår om til en funktion af x
unapply(udtryk,x,y) Lav et udtryk om til en funktion af flere variable
Differentiering, integration, grænseværdier:
diff(udtryk,x) Differentier et udtryk med hensyn til x
diff(udtryk,x,y) Differentier et udtryk med hensyn til først x og dernæst y
Diff Det samme som diff, men rent symbolsk (forsinket)
D(f ) Den afledte funktion af funktionen f af en enkelt variabel
int(udtryk,x) Integrer et udtryk over x
int(udtryk,x=a..b) Integrer et udtryk over intervallet [a,b]
Int Det samme som int, men rent symbolsk (forsinket)
limit(udtryk,x=værdi) Grænseværdien for et udtryk for x gående mod en given værdi
limit(udtryk,x=værdi,left) Grænseværdien for et udtryk for x gående mod en given værdi fra venstre
limit(udtryk,x=værdi,right) Grænseværdien for et udtryk for x gående mod en given værdi fra højre
limit(udtryk,x=infinity) Grænseværdien for et udtryk for x gående mod uendelig
limit(udtryk,x=-infinity) Grænseværdien for et udtryk for x gående mod minus uendelig
Limit Det samme som limit, men rent symbolsk (forsinket)
value(udtryk) Tag værdien af et udtryk der indeholder Diff, Int eller Limit
Sekvenser, lister og mængder:
udtryk1,udtryk2, ... En sekvens
[udtryk1,udtryk2,...] En liste
{udtryk1,udtryk2,...} En mængde
X[i] Indeksering; element nummer i ud af sekvensen/listen/mængden X
X[i..j] Elementerne i til j af sekvensen/listen/mængden X, som en ny sekvens/liste/mængde
A union B Foreningsmængden af mængderne A og B
A intersect B Fællesmængden for mængderne A og B
A minus B Mængdedifferensen mellem mængderne A og B
seq(udtryk,x=i..j) Generer en sekvens af værdier hvor x i udtrykket erstattes af heltallene fra i til j
map(funktion,A) Anvend en funktion på hvert element i (listen/mængden/tabellen) A
select(funktion,A) Udvælg de elementer fra A for hvilke funktionen giver værdien sand
Tabeller:
array(m..n) Opret en tabel med pladser indekseret fra m til n
array(m..n,liste) En tabel indekseret fra m til n, de første elementer initialiseres fra en liste
array(liste) En tabel indekseret fra 1 indeholdende værdierne fra en liste
T[i] Element nummer i fra tabellen T
T[i]:=udtryk Tildel et udtryk til element i i tabellen T
array(k..l,m..n) Opret en todimensionel tabel
T[i,j] Element i,j fra en todimensionel tabel T
table() Opret en (tom) associativt indekseret tabel
table(liste) Opret en associativt indekseret tabel fra en liste elementer af formen indeks=værdi
A[indeks] Elementet i den associativt indekserede tabel A associeret til indeks
A[indeks]:=udtryk Lav en associering fra indeks til udtryk i den associativt indekserede tabel A
A[indeks]:=’A[indeks]’ Fjern associering til indeks i den associativt indekserede tabel A
print(X) Vis indholdet af tabellen X
Substitutioner:
eval(udtryk,x=værdi) Evaluer et udtryk hvor en given værdi substitueres for x
eval(udtryk,mængde) Tilsvarende, med flere substitutioner angivet som en mængde ligninger venstre=højre
eval(udtryk,liste) Tilsvarende, med flere substitutioner angivet som en liste af ligninger venstre=højre