Lathund Maple abs Funktionen för att bestämma absolutbeloppet abs(23-134); 111 add adderar en sekvens av tal add(i^2,i=1..5); 55 add(i^2,i in [1,4,6]); 53 sum(i,i=1..10); f:=x->x^2; add(f(i),i=1..3); 14 Här summeras i första raden 1 2 + 2 2 + 3 2 + 4 2 + 5 2 = 55 och i andra raden hämtas talen 1, 4, 6 fram för kvadrering och summering. sum kan användas här som ett alternativ. add kan kombineras med en funktion. Append (lägga till element) Vi skiljer mellan sekvens, mängd och lista. Här ska vi se hur man lägger till ett element sist i respektive objekt m:=seq(i,i=1..3); 1, 2, 3 m:=m,3; 1, 2, 3, 3 m:={1,2,3,5}; {op(m),6}; {1, 2, 3, 5, 6} m:=[1,4,8,12]; [op(m),14]; [1, 4, 8, 12, 14] m:=[1,2]; n:=[3,4]; [op(m),op(n)]; [1, 2, 3, 4] I sista exemplet slår vi ihop två listor till en Håkan Strömberg 1 KTH Syd
apply Tillämpa en funktion på en sekvens m:=1,2; apply( +,m); 3 apply( *,m); 2 apply( -,m); -1 apply( /,m); 1/2 Observera att m här är en sekvens. Detta exempel visar skillnaden mellan apply och map apply(v,$1..3); v(1, 2, 3) map(v,[$1..3]); [v(1), v(2), v(3)] binomial binomial(m,n) bestämmer m! n!(m n)! binomial(10,3); 120 sum(binomial(10,i),i=0..10); 1024 Det finns 120 möjligheter att plocka ut 3 element ur en mängd med 10 element. Den andra tillämpningen summerar talen på dem 11 : e raden i Pascals triangel. Håkan Strömberg 2 KTH Syd
choose För att välja ut delmängder eller dellistor från en given mängd eller lista. choose({a,b,c}); {{},{a,b},{b},{a},{a, c, b},{c, b},{c},{a, c}} choose([a,b,b]); [[],[b],[b, b],[a],[a, b],[a, b, b]] choose([a,b,c],2); [[a,b],[a,c],[b,c]] choose({a,b,b,c,c,c},2); {{a, b}, {c, b}, {a, c}} Ett sätt att få fram alla delmängder till mängden {a, b, c} (jämför subset). Ett sätt att få fram alla dellistor till en given lista [a, b, b], allt från den tomma listan till hela listan. Ett sätt att få fram alla dellistor med ett bestämt antal element, här 2. Ett sätt att få fram alla delmängder med ett bestämt antal element, här 2 (inga dubbletter). combinat Ett bibliotek som innehåller kombinatoriska funktioner, bland annat subsets, choose, permute with(combinat); convert convert([1,2,4,3,2,1],set); {1, 2, 3, 4} m:=convert({1,2,4},list); [1,2,4] convert(37, binary); 100101 convert(1/2, float); 0.5000000000 Vi konverterar en lista till en mängd och ser att att dubbletter försvinner. Vi konverterar en mängd till en lista. Konvertering till binär form är också möjlig, liksom till flyttal. Håkan Strömberg 3 KTH Syd
divisors Funktionen finns i biblioteket numtheory och ger en mängd över de tal som delar n with(numtheory); divisors(12345); Vi får svaret {1, 3, 5, 15, 823, 2469, 4115, 12345}. Dessa tal är alla en delare till 12345 $, dollartecken Kan användas som kort variant för att generera sekvens m1:=$3..20; m2:={$1..10}; m3:=[$300..400]; Vi genererar en sekvens, en mängd och en lista. for Två exempel där vi summerar talen i en lista m:=[1,2,3,4,5,7]; s:=0; for i from 1 to 6 do s:=s+m[i]; end do; s:=0; for i in m do s:=s+i; end do; I det första fallet är det index som löper från 1 till 6. I det andra antar i talen i listan i tur och ordning. For-loopen avslutas med end do eller od. med hjälp av by kan man ange ett steg för loopvariabeln. Håkan Strömberg 4 KTH Syd
FromDigits Genom biblioteket nedan kommer vi åt funktionen FromDigits with(mmatranslator[mma]): FromDigits([4, 6, 3, 8]); 4638 Som översätter en lista med siffror som element till ett tal. Funktion (enradig) f:=x->x^2; f(10) 100 hyp:=(x,y)->sqrt(x^2+y^2); hyp(3,4); 5 f1:=(x,y,z)->[y,x,z]; f1(2,3,4); [3,2,4] f tar emot ett tal x och returnerar x 2. hyp tar emot två katetrar och returnerar hypotenusan. f1 tar emot tre tal och returnerar en lista med dessa tal i annan ordning Funktion (flerradig) Här skelettet till en funktion, vi kallar funk, i Maple funk:=proc(...) local...... return... end proc: Finns det inga lokala variabler behövs inte local. Vill man inte returnera något (ovanligt) behövs inte return. Istället för return kan man använda print. gcd Bestämmer största gemensamma delaren till två heltal gcd(13668,6097); 67 Håkan Strömberg 5 KTH Syd
ifactor Funktionen faktoriserar ett heltal i sina primfaktorer ifactor(360); Vi får 2 3 3 2 5 ifactors Faktoriserar ett helta och ger ett lite annorlunda och kanske mer användbart resultat än ifactor. ifactors(24696); [1,[[2,3],[3,2],[7,3]]] Resultatet hamnar i en lista, som i sin tur består av ett tal 1 eller 1 för att hålla reda på talets tecken. Därefter följer en lista bestående av två element långa underlistor. Varje sådan underlista, innehåller först en primfaktor och sedan antalet sådana faktorer som ingår. 2 3 3 2 7 3 = 24696 indicering För att nå enskilda element eller delsekvenser i en lista använder man sig av indicering m:=[1,3,7,10,12]: m[3]; 7 m[2..4]; [3, 7, 10] m2:=m[4..5]; m2:=[10,12] IntegerDigits En funktion som vi ofta använder IntegerDigits:=x->Reverse(convert(x,base,10)): IntegerDigits(1234); [1,2,3,4] Funktionen översätter ett heltal n till en lista med talets siffror. Håkan Strömberg 6 KTH Syd
intersect Bildar snittet av två mängder m1:={1,3,5,6}: m2:={3,6,8,9}: m1 intersect m2; {3, 6} iquo Heltalsdivision. iquo(25,3); 8 Kan också ordnas med trunc(25/3) irem Resten vid division irem(25,3) 1 Kan också ordnas med 25 mod 3 isprime För att testa om ett heltal är primtal isprime(1261601560123913); true Håkan Strömberg 7 KTH Syd
issqrfree Funktionen issqrfree(n) returnerar true om det inte finns någon heltalskvadrat som delar n ifactor(98); issqrfree(98); false ifactor(102); issqrfree(102); true Första raden returnerar primfaktorerna för 98 = 2 7 2. Alltså är talet 49 en delare till 98 och därför är inte 98 squarefree. I tredje raden får vi veta att 102 = 2 3 17 och kan direkt se att ingen heltalskvadrat delar 102, som då alltså är squarefree ithprime Ger det i:e primtalet ithprime(100); 541 pi(541); 100 Det 100:e primtalet är 541. Då bör det finnas 100 primtal 541, vilket pi visar. local För att deklarera lokala variabler i en funktion. Inte alltid nödvändigt, men man slipper varningstext funk:=proc(x) local s,m; m:=[]; for s from 1 to x do m:=[op(m),s]; end do; return m; end proc; Ett lite omständligt sätt att skapa en lista [1...x]. m är en lokal variabel för en lista, som måste initieras innan den kan användas, här till tomma listan. Observera också hur man gör för att lägga till ett element sist i listan m. Håkan Strömberg 8 KTH Syd
Logiska operatorer Vi använder följande logiska operatorer i denna kurs och &and eller &or icke ¬ implikation &implies ekvivalens &iff Här ett exempel på hur vi kan bestämma sanningshalten i uttrycket (a b) (a b) with(logic): a:=true: b:=false: Export((a &and b) &implies (a &iff b)); true Observera att man måste använda funktionen Export och att operatorerna finns i biblioteket Logic map Funktionen map tillämpar funktionen f på elementen i en lista och returnerar en lista f:=proc(x) return x^2; end proc; map(f,[2,4,9]); [4 16 81] minus Bildar differensen av två mängder m1:={1,3,5,6}: m2:={3,6,8,9}: m1 minus m2; {1, 5} m2 minus m1; {8, 9} Håkan Strömberg 9 KTH Syd
mul Multiplicerar talen i en sekvens mul(i,i=1..5); 120 5! 120 Här används mul för att på ett omständligare sätt bestämma 5!, vilket kan göras direkt i Maple nops Ger antalet element i en lista m1:=[23,4,5,22]; nops(m1); m2:=[[1,2],[3,4],[5,6]]; nops(m2); nops(m2[1]); m1 har förstås 4 element. Observera att m2 har 3 element och inse varför den sista raden ger resultatet 2. numtheory Ett bibliotek från vilket vi bland annat kan få tillgång till pi, divisors och issqrfree with(numtheory); pi(1000); Exemplet ger svaret 168 eftersom det finns så många primtal < 1000. pi Funktionsanropet pi(1000000) talar om att det finns 78498 primtal som är < 1000000. Håkan Strömberg 10 KTH Syd
permute Genererar samtliga permutationer av elementen i en lista permute([1,2,3]); [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] permute([1,2,3],2); [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]] permute([c,c,d,d],2); [[c,c],[c,d],[d,c],[d,d]] I andra och tredje exemplet plockar vi ut alla kombinationer av två element och permuterar dem. rand Enklaste sättet att få fram slumptal roll:=rand(1..6); roll(); 3 seq(roll(),i=1..5); 1, 5, 2, 3, 2 Vi definierar en funktion, till exempel roll där vi anger i vilket intervall vi vill ha slumptalen. Sedan anropar vi funktionen roll på lämpligt sätt. return För att returnera resultat från funktion f:=proc(a,b) local c; c:=sqrt(a^2+b^2); return [a,b,c]; end proc: f(3,4); [3, 4, 5] En funktion som bestämmer hypotenusan för givna katetrar och som returnerar en lista där även indata ingår. Håkan Strömberg 11 KTH Syd
Reverse Vänder på en lista Reverse([3,5,9]); [9, 5, 3] Rotate Roterar elementen i en lista angivet antal steg Rotate([1,2,3,4,5],4); [5, 1, 2, 3, 4] SearchAll För att söka efter element i en lista eller mängd slump:=rand(1..6): m:=[seq(slump(),i=1..200)]: SearchAll(3,m); nops([searchall(3,m)]); Vi startar med att slumpens hjälp skapa en lista, som får namnet m. Vi är nu intresserade av var i listan talet 3 förekommer. Med hjälp av SearchAll får vi en sekvens med index (platsnummer). Vill vi ta reda på hur många 3:or det finns i listan ordnar vi det med nops. Observera hur vi tvingas använda hakparenteser för att ska listor. Ett alternativt sätt till att ta reda på antalet är Occurrences(3,m); 25 seq(occurrences(i,m),i=1..6); 43, 33, 25, 38, 23, 38 select Denna funktion används ofta för att med hjälp av en boolsk funktion f (returnerar true eller false) välja ut kandidater från en lista. f:=proc(x) return isprime(x[1]) and isprime(x[2]); end proc; m:=select(f,[[2,4],[3,7],[9,11]]); [[3,7]] Funktionen f tar emot en lista med två tal och returnerar true om båda är primtal. Listan m kommer att innehålla ett element listan [3, 7] Håkan Strömberg 12 KTH Syd
seq seq(i,i=1..5); 1, 2, 3, 4, 5 seq(i,i=1..13,3); 1, 4, 7, 10, 13 seq(seq([i,j],i=1..3),j=1..2); [1, 1], [2, 1], [3, 1], [1, 2], [2, 2], [3, 2] [seq(i^3,i=1..4)]; [1, 8, 27, 64] Genererar sekvenser. I andra exemplet ser vi hur man använder steget 3 i sekvensen. I tredje genererar vi en sekvens av listor och till slut visar vi hur en sekvens kan göras till en lista solve För att lösa en ekvation eller ett ekvationssystem solve(4*x^2-8*x-60=0); 5, -3 solve({3*x+4*y=10,5*x-3*y=7}); {x = 2, y = 1} När det gäller ett ekvationssystem samlar man ekvationerna i en mängd eller lista. subset returnerar true om den första mängden är en delmängd av den andra {adam,bertil} subset {curt,bertil,adam}; true Håkan Strömberg 13 KTH Syd
subsets Denna funktion används på ett lite speciellt sätt. m:=subsets({1,2,3}). Funktionen tar emot en mängd och bildar alla delmängder. I vårt exempel får vi 8 stycken {},{1},{2},{3},{1,2},{1,3},{2,3},{1,2,3} Denna sekvens av mängder visas dock inte på skärmen! m:=subsets({1,2,3}): f:=proc(m) local p,s,t; t:=[]; while not m[finished] do p:=m[nextvalue](); s:=add(i,i in p); t:=[op(t),s]; end do; return t; end proc: f(m); [0, 1, 2, 3, 3, 4, 5, 6] Om vi nu vill summera elementen i var och en av de 8 delmängderna får vi ju listan ovan (sista raden). För att åstadkomma detta skriver vi en funktion f som har m (sekvensen av delmängder) som parameter. While-loopen kommer i vårt exempel att snurra 8 varv. Med hjälp av m[finished] tar vi reda på om sekvensen är slut. Med hjälp av m[nextvalue]() tar vi fram den delmängd som står på tur. union Bildar unionen av två mängder m1:={1,3,5,6}: m2:={3,6,8,9}: m1 union m2; {1, 3, 5, 6, 8, 9} sort Sorterar en lista sort(m): sort(m, > ): Med hjälp av > och < kan man bestämma om sorteringsordningen ska vara avtagande eller fallande. Håkan Strömberg 14 KTH Syd
while Fungerar i stort som i andra språk. Vi använder konstruktionen företrädesvis i funktioner f:=proc() local a; a:=1; while a^2<10000 do a:=a+1; end do; return a-1; end proc; Efter villkoret tillfogas ett do. Loopen avslutas med ett end do eller od Håkan Strömberg 15 KTH Syd