Maple: Simplifikation af udtryk og løsning af ligninger

Databehandling 2005 

Forelæsning 19, tirsdag 26. april 2005 

Oversigt 

• Sekvenser, lister og mængder 

• Simplifikation og manipulation af udtryk 

• Løsning af ligninger 

• Løsning af differentialligninger 

• Et eksempel fra Matematisk Grundkursus 

Databehandling 2005 KVL Side 19-1 

Sekvenser 

Nogle af Maples funktioner giver svar i form af en sekvens af udtryk. 

En sekvens er simpelt hen en række udtryk adskilt af kommaer. Man kan selv indtaste sekvenser: 

> 10, x, sin(x); 

10, x, sin(x) 

Man kan binde en sekvens til et navn med en tildeling: 

> sekvens:=10, x, sin(x); 

sekvens := 10, x, sin(x) 

Man kan udtage enkelte elementer eller delsekvenser med indeksoperatoren [ ]: 

> sekvens[1]; sekvens[2..3]; 

10 

x, sin(x) 


Lister 

Ofte har man brug for at give en liste af værdier eller udtryk til Maples funktioner. 

Somme tider får man også resultater i form af lister. 

En liste er en sekvens "pakket ind" i kantede parenteser: 

> liste1:=[a,b,c,d]; 

liste1 := [a, b, c, d] 

Man kan konvertere en sekvens til en liste simpelt hen ved at komme kantede parenteser om: 

> liste2:=[sekvens]; 

liste2 := [10, x, sin(x)] 

Man kan udtage enkelte elementer og dellister med indeksoperatoren: 

> liste1[2..3]; liste2[2]; 

[b, c] 

x 


Mængder 

Man kan også have brug for at give en mængde af værdier eller udtryk til Maples funktioner eller man kan få 

resultater i form af mængder. 

Man skriver en mængde som en sekvens "pakket ind" i krøllede (mængde) parenteser og kan konvertere 

sekvenser til mængder på den forventede måde: 

> mængde1:={a,b,c,d}; mængde2:={sekvens}; 

mængde1 := {a, b, c, d} 

mængde2 := {10, x, sin(x)} 

I modsætning til for lister og sekvenser bevares rækkefølgen af elementer ikke i en mængde, og eventuelle 

gentagelser fjernes. 

Maples mængdebegreb svarer dermed til de mængder man kender fra matematik. 

Det er muligt at tage fællesmængde, foreningsmængde og mængdedifferens: 

> mængde1 union {d,e,f}; mængde1 intersect {d,e,f}; 

> mængde1 minus {d,e,f}; 

{a, b, f, c, e, d} 

{d} 

{a, b, c} 

Databehandling 2005 KVL Side 19-4

Simplifikation af udtryk med simplify 

Som nævnt ved sidste forelæsning konverterer Maple ikke automatisk indtastede udtryk til den simpleste form, 

men man kan bruge simplify til at forsimple med: 

> exp(a+ln(b*exp(c))); 

> simplify(%); 

> cos(x)^2+sin(x)^2; 


> x*(x+4)+x^2+(x+1)*(x-3)+2; 


e (a+ln(b ec )) 

b e (a+c) 

cos(x) 2 + sin(x) 2 

1 

x (x + 4) + x 2 + (x + 1) (x − 3) + 2 

3 x 2 + 2 x − 1 

Ved første øjekast kan simplify synes som den mest nyttige funktion i Maple overhovedet. Men den har sine 

begrænsninger. 

Det er nemlig ikke veldefineret hvad der er den "simpleste form" af ethvert matematisk udtryk – den bedste form 

afhænger af hvad man skal bruge udtrykket til. 


Manipulation af udtryk med expand og factor 

Funktionen expand ændrer et udtryk ved at gange alle parenteser ud (distribuere produkter over summer) og 

derefter samle led af samme potenser. 

> expand(x*(x+4)+x^2+(x+1)*(x-3)+2); 

3 x 2 + 2 x − 1 

Den modsatte af at ekspandere et udtryk er at forsøge at faktorisere det til et produkt af polynomier af mindst 

mulig grad. 

Dette gøres med funktionen factor: 

> factor(%); 

(x + 1)(3 x − 1) 

Denne form af polynomiet er nyttig for nu kan vi direkte se at rødderne er -1 og 1 3 . 

Det er muligt at bede expand om at lade visse underudtryk forblive uekspanderede: 

> expand((a+b)*(c+d)); expand((a+b)*(c+d),a+b); 

a c + a d + b c + b d 

(a + b) c + (a + b) d 


Mere om expand og factor, samt normal 

Funktionerne expand og factor virker også på rationelle udtryk. 

> (x+1)*(x-2)/(x-5); 

(x + 1) (x − 2) 

x − 5 

> expand(%); 

x2 x 

− 

x − 5 x − 5 

1 

− 2 

x − 5 

Med funktionen normal kan man bringe et rationelt udtryk på faktoriseret normal form, d.v.s. som en brøk hvor 

tæller og nævner er polynomier der ikke går op i hinanden. 

> normal(%); 

x 2 − x − 2 

x − 5 

Endelig kan man bruge factor for at faktorisere tæller og nævner igen: 

> factor(%); 

(x + 1) (x − 2) 

x − 5 


Manipulation af udtryk med expand og combine 

Med expand kan man også ekspandere en lang række udtryk der indeholder specielle funktioner. 

> expand(cos(x+y)); 

cos(x) cos(y) − sin(x) sin(y) 

Her kan man ikke bruge factor for at gå den anden vej, men ofte kan man bruge funktionen combine: 

> combine(%); 

> expand(exp(a+b)); 

> combine(%); 

> expand(Int(x+1,x)); 

> combine(%); 

> expand(exp(sin(a+b))); 

> combine(%); 

 

cos(x + y) 

e a e b 

e (a+b) 

 

x dx + 1 dx 

 

x + 1 dx 

e (sin(a) cos(b)) e (cos(a) sin(b)) 

e sin(a+b) 


Manipulation af polynomier med collect 

I polynomier i flere variable kan man samle koefficienterne for bestemte variable med funktionen collect. 

> poly:=x^2+5*x+2*x*y+y+y*z+3*x*z; 

> collect(poly,x); 

> collect(poly,y); 

poly := x 2 + 5 x + 2 x y + y + y z + 3 x z 

x 2 + (5 + 2 y + 3 z) x + y z + y 

(2 x + 1 + z) y + x 2 + 5 x + 3 x z 

Vi kan også bede om at få samlet koefficienterne først for x og dernæst for y: 

> collect(poly,[x,y]); 

x 2 + (5 + 2 y + 3 z) x + (z + 1) y 

Endelig kan vi bede om at få koefficienter samlet på produkter af visse variable frem for først for én variabel og 

dernæst for den næste variabel: 

> collect(poly,[x,y],distributed); 

x 2 + 2 x y + (z + 1) y + (5 + 3 z) x 


Sortering af polynomier med sort 

Maple sorterer ikke nødvendigvis leddene i et polynomium efter faldende potenser af de variable som man 

sædvanligvis gør. 

Faktisk lader Maple et polynomium stå som man indtaster det: 

> poly:=2*x+x^3-2+6*x^2; 

poly := 2 x + x 3 − 2 + 6 x 2 

Med funktionen sort kan man få sorteret efter potenser: 

> sort(poly); 

x 3 + 6 x 2 + 2 x − 2 

Sortering er “destruktiv” og ændrer det oprindelige polynomium. 

> poly; 

x 3 + 6 x 2 + 2 x − 2 

Faktisk kan Maple huske hvilke polynomier der er set før så selv om man taster den oprindelige form ind igen får 

man den sorterede form: 

> 2*x+x^3-2+6*x^2; 

x 3 + 6 x 2 + 2 x − 2 

Der skal en restart kommando til for at få Maple til at glemme sorteringen af et polynomium. 


Mere om sort 

For polynomier i flere variable kan man angive hvilke variable der skal sorteres efter: 

> a*x+b*y^2+c*x^2*y+5+y; 

> sort(%,[x,y]); 

> sort(%,[y,x]); 

> sort(%,[x]); 

a x + b y 2 + c x 2 y + 5 + y 

c x 2 y + b y 2 + a x + y + 5 

c y x 2 + b y 2 + y + a x + 5 

c y x 2 + a x + b y 2 + y + 5 


Løsning af ligninger 

En ligning er blot et udtryk der indeholder et lighedstegn. 

> lign:=a*x+b=0; 

lign := a x + b = 0 

Maple kan løse ligninger algebraisk med funktionen solve. Man angiver en ligning og den ukendte man ønsker 

at finde. 

> solve(lign,x); 

Ved at angive den ukendte "pakket ind" i en mængde får man løsningen på en alternativ form: 

> solve(lign,{x}); 

− b 

a 

{x = − b 

a } 

Denne form for løsning er praktisk fordi man kan anvende den direkte i eval til at kontrollere løsningen: 

> eval(lign,%); 

0 = 0 


Løsning af ligninger fortsat 

Hvis en ligning er et polynomuim og har flere løsninger giver solve resultatet som en sekvens af løsninger: 

> lign:=x^2-13*x+40=0; 

> løs:=solve(lign,{x}); 

lign := x 2 − 13 x + 40 = 0 

løs := {x = 5}, {x = 8} 

Man må så indeksere sig frem til den enkelte løsning hvis man for eksempel ønsker at kontrollere dem med 

eval: 

> eval(lign,løs[1]), eval(lign,løs[2]); 

0 = 0, 0 = 0 


Løsning af ligningssystemer 

Med solve kan man også løse ligningssystemer. 

Man angiver systemet som en mængde af ligninger: 

> lign:={x+y=5,x-y=1}; 

lign := {x + y = 5, x − y = 1} 

> løs:=solve(lign,{x,y}); 

løs := {y = 2, x = 3} 

Man kan igen anvede eval for at kontrollere sin løsning: 

> eval(lign,løs); 

{1 = 1, 5 = 5} 

Man kan også nemt anvende eval for at få den enkelte ukendte: 

> eval(x,løs); 

3 

Man kan medtage uligheder i den mængde af ligninger der skal løses: 

> solve({x^2=4,x>0},{x}); 

{x = 2} 

Man kan også løse systemer bestående alene af uligheder (se noterne). 


Løsninger med RootOf 

Nogle gange giver solve en del af løsningsmængden som funktionen RootOf anvendt på et udtryk 

indeholdende et automatisk genereret variabelnavn. 

RootOf betyder at løsningerne til det oprindelige problem er rødder i det angivne udtryk (som Maple ikke kan 

finde rødderne til algebraisk). 

Faktisk foretrækker Maple også at give løsninger til fjerdegradsligninger der ikke har heltalsløsninger i form af en 

RootOf-løsning. 

Dette er fordi løsningerne generelt er så komplicerede at de er meget vanskelige at læse. 

Tag for eksempel denne fjerdegradsligning: 

> lign:=x^4-3*x+5; 

> løs:=solve(lign,{x}); 

lign := x 4 − 3 x + 5 

løs := {x = RootOf(_Z 4 − 3 _Z + 5, index = 1)}, {x = RootOf(_Z 4 − 3 _Z + 5, index = 2)}, 

{x = RootOf(_Z 4 − 3 _Z + 5, index = 3)}, {x = RootOf(_Z 4 − 3 _Z + 5, index = 4)} 


“Udpakning” af en RootOf løsning 

Hvis man tager allvalues til en RootOf løsning får man den algebraiske løsing, hvis den findes, ellers får 

man bare samme RootOf løsning igen. 

For fjerdegradsligningen fra før er udtrykkene så indviklede at der ikke er plads til bare en enkelt løsning på denne 

transparent. 

Man kan med fordel gå direkte til numeriske løsninger ved at anvende evalf: 

> evalf(løs); 

{x = 1.081909857 − .6908765240 I }, {x = 1.081909857 + .6908765240 I }, 

{x = −1.081909857 + 1.365191381 I }, {x = −1.081909857 − 1.365191381 I } 

For visse RootOf udtryk (med periodiske funktioner) kan Maple gå i en uendelig løkke hvis man beder om en 

allvalues løsning. 

Man kan dog altid bruge “stop” knappen til at afbryde beregningen. 


solve’s begrænsninger 

Når solve ikke kan finde en løsning giver den et tomt svar: 

> solve({x^2=4,x>10},{x}); 

Nogle gange finder solve desværre heller ikke alle løsninger, specielt ikke hvis trigonometriske funktioner er 

involveret. 

Nedenstående ligning har for eksempel seks løsninger hvoraf solve kun finder en enkelt RootOf løsning: 

> solve(sin(x)+x^2/100=0,{x}); 

> evalf(%); 

{x = RootOf(100 sin(_Z) + _Z 2 , label = _L1046)} 

{x = 0.} 


Numerisk løsning af ligninger 

Når man ikke kan finde løsninger algebraisk kan man forsøge sig numerisk. 

Funktionen fsolve forsøger numerisk at finde en enkelt løsning til en ligning (dog alle løsninger hvis der er tale 

om et polynomium). 

> fsolve(sin(x)+x^2/100=0,{x}); 

{x = 0.} 

Som standard leder fsolve kun efter reelle løsninger. Hvis man vil have komplekse løsninger må man eksplicit 

bede om det: 

> lign:=2*x^6-9*x^5+4*x^4-18*x^3-8*x+36=0; 

lign := 2 x 6 − 9 x 5 + 4 x 4 − 18 x 3 − 8 x + 36 = 0 

> fsolve(lign,{x}); 

{x = 1.080814100}, {x = 4.500000000} 

> løs:=fsolve(lign,{x},complex); 

løs := {x = −.8052581887 − .8818333295 I }, {x = −.8052581887 + .8818333295 I }, 

{x = .2648511385 − 1.589036316 I }, {x = .2648511385 + 1.589036316 I }, 

{x = 1.080814100}, {x = 4.500000000} 


Mere om fsolve 

Det er ikke alle numeriske løsninger der er lige præcise: 

> eval(lign,løs[1]); eval(lign,løs[3]); 

0 = 0 

.4 10 −7 − .2 10 −7 I = 0 

Det samme gør sig gældende med løsninger fundet med evalf-ekspansion af en RootOf-løsning. 

Selv om fsolve kun giver en enkelt løsning for ikke-polynomier er der flere muligheder for sucessivt at finde 

flere løsninger; det er beskrevet i noterne. 


Løsning af differentialligninger 

En ordinær differentialligning løses med funktionen dsolve. 

Hvis man bare giver en ligning uden begyndelsesbetingelser får man den fuldstændige løsning: 

> lign:={diff(y(t),t,t)+4*y(t)=0}; 

> dsolve(lign,{y(t)}); 

Maple generere automatisk de nødvendige konstanter. 

lign := {( d2 

dt 2 y(t)) + 4 y(t) = 0} 

y(t) = _C1 sin(2 t) + _C2 cos(2 t) 

For at få en partikulær løsning kan vi tilføje begyndelsesbetingelser: 

> bb:={y(0)=3,D(y)(Pi/2)=10}; 

bb := {y(0) = 3, D(y)( 1 

π) = 10} 

2 

> løs:=dsolve(lign union bb,{y(t)}); 

løs := y(t) = −5 sin(2 t) + 3 cos(2 t) 


Kontrol af løsningen til differentialligningen 

Vi kan verificere at den fundne løsning opfylder ligningen direkte ved at bruge eval: 

> eval(lign,løs); 

{0 = 0} 

For at kontrollere at begyndelsesbetingelserne er overholdt er vi dog nødt til at lave løsningen om til en funktion: 

> eval(y(t),løs); 

> y1:=unapply(%,t); 

> eval(bb,y=y1); 

Vi kan også kontrollere at y1 opfylder ligningen: 

> eval(lign,y=y1); 

−5 sin(2 t) + 3 cos(2 t) 

y1 := t → −5 sin(2 t) + 3 cos(2 t) 

{10 = 10, 3 = 3} 

{0 = 0} 


Eksempel 

Opgave 5 fra eksamen i Matematisk Grundkursus December 1998: 

Givet den lineære 1. ordens differentialligning 

dy 

dx + (2a − 6)y = 18eax . (L) 

hvor a ∈ R er en konstant. 

(1) Sæt a = 1 og bestem derefter den løsning y = ϕ(x) til (L) der er fastlagt ved begyndelsesbetingelsen 

ϕ(0) = 7. 

(2) Find den værdi af a for hvilken (L) tilfredsstilles af funktionen y = 2e 5x . Løs derefter, med den fundne værdi 

af a indsat, ligningen (L) fuldstændigt. 

(3) [Vanskeligt spørgsmål.] Løs (L) fuldstændigt for vilkårlig a ∈ R. Løsningen skal angives i form af en ligning for 

y udtrykt ved x og a samt en arbitrær konstant c. Det bemærkes, at løsningen kan afprøves for de værdier af a, 

der optrædte i (1) og (2), men denne afprøvning ønskes ikke anført i besvarelsen. 


Løsning af (1) i Maple 

> restart; 

> lign:=diff(y(x),x)+(2*a-6)*y(x)=18*exp(a*x); 

lign := ( d 

dx y(x)) + (2 a − 6) y(x) = 18 e(a 

x) 

> dsolve({eval(lign,a=1),y(0)=7},{y(x)}); 

Kontrol af løsningen: 

> eval(lign,{a=1,%}); 

y(x) = −6 ex + 13 e (4 x) 

18 e x = 18 e x 



For at finde den ønskede værdi af a er vi nødt til at løse en ligning der skal gælde for alle x. Dette gøres med 

solve sammen med den specielle funktion identity (se Maple noterne): 

> solve(identity(eval(lign,y(x)=2*exp(5*x)),x),a); 

Herfra er resten stort set en gentagelse af (1) bare uden begyndelsesbetingelse: 

> dsolve(eval(lign,a=5),y(x)); 

Kontrol af løsningen: 

> eval(lign,{a=5,%}); 


5 

y(x) = (2 e (9 x) + _C1) e (−4 x) 

18 e (−4 x) e (9 x) = 18 e (5 x) 

18 e (5 x) = 18 e (5 x) 



> dsolve(lign,y(x)); 

Denne løsning må kunne skrives pænere: 

> expand(%); 

> combine(%); 

e(−2 

(a−3) x+(3 a−6) x) 

y(x) = 18 + e 

3 a − 6 

(−2 (a−3) x) _C1 

y(x) = 

y(x) = 

18 e(a x) 

3 a − 6 + (ex ) 6 _C1 

(e (a x) ) 2 

18 e(a 

x) 

+ _C1 e(−2 

a x+6 x) 

3 a − 6 

Den fundne løsning gælder for alle a ∈ R undtagen a = 2, så vi er nødt til at løse specielt for denne værdi af a: 

> dsolve(eval(lign,a=2),y(x)); 

> combine(expand(%)); 

y(x) = (18 x + _C1) e (2 x) 

y(x) = 18 e (2 x) x + e (2 x) _C1 


Sammenfatning 

• Man kan forsimple udtryk med simplify men kan også med fordel eksperimentere med expand, 

factor, combine og normal. 

• Man kan omforme polynomier med collect og sort. 

• Man kan løse ligninger, ligningssystemer og uligheder algebraisk med solve. 

• Man kan løse ligninger (og ligningssystemer) numerisk med fsolve. 

• Man kan løse ordinære differentialligninger med dsolve. 

Læs: Maple noter afsnit 12–16 (denne forelæsning) og afsnit 17–18 (næste forelæsning).

Maple: Simplifikation af udtryk og løsning af ligninger

Create successful ePaper yourself

Delete template?

Save as template?