Alapvető tudnivalók a Maple-ről
A beírt sort az ENTER hatására futtathatjuk. Amenyiben a sor végén pontosvessző áll, úgy kiírja a végeredményt. Ha kettőspont, úgy csak kiszámolja, de nem írja ki. A későbbiek során szükség lesz arra, hogy egy sort még ne számoljon ki (pl. programok írásakor), ilyenkor SHIFT ENTER-t kell nyomni minden sor végén, kivéve az utolsót.
> | 1+1; |
> | 1+1: |
> | 15!; |
> | 15!: |
Amennyiben túl hosszú a beírt sor, akkor nem írja ki.
> | 15000!; |
Fontos, hogy minden egyes parancsnál számít a nagy és kisbetű.
> | Pi; |
> | 1+3/2; |
> | 2+Pi/2; |
Nincs olyan beépített parancs, hogy Sin, nagy S-sel.
> | Sin(Pi); |
> | sin(Pi); |
Van pár beépített szimbólum, mint például a Pi. A Pi-vel, mint szimbólummal tud számolni, így külön meg kell kérnünk, ha a közelítését akarjuk kiíratni. Az evalf lebegőpontos (float) alakra hoz, az evalm mátrixok kiértékelésére szolgál.
> | evalf(Pi); |
> | evalf(sin(1)); |
Állítható a számolandó pontosság:
> | evalf(Pi,30); |
Illetve globálisan beállítható az elvárt pontosság. Ezután kérés nélkül 20 jegy pontsan számol mindent, így az evalf(Pi) esetén is 20 jegy hosszú eredményt ad
> | Digits:=20; |
> | evalf(Pi); |
Előző parancs futásának eredménye: %
> | 2*%; |
Értékadás :=
> | x:=3; |
> | alpha:=5; |
> | x; |
Értéket így törölhetünk:
> | x:='x'; |
> | x; |
Prímtényezőkre bontás:
> | ifactor(60); |
Legnagyobb közös osztó:
> | igcd(120,20); |
> | isprime(18002676583); |
> | sqrt(2); |
> | sqrt(2)^2; |
Modulo legkisebb abszolútértékű maradékkal:
> | mods(27,4); |
> | modp(27,4); |
> | 27 mod 4; |
> | Diff(sin(x),x); |
> | value(%); |
> | sum(n^2,n=1..k); |
> | sum(1/n^2,n=1..infinity); |
Formázások
Munka közben hasznos a CTRL-DEL parancs, amellyel az aktuális cella eredményét, illetve magát a cellát tudjuk törölni. Az aktuális cella elé CTRL-K-val, mögé CTRL-J-vel adhatunk új cellát, illetve SHIFT-CTRL-K-val a cellán belül a képlet elé, SHIFT-CTRL-J-vel a cellán beül a képlet mögé írhatunk megjegyzést (ez is most egy megjegyzés). A kijelölt vagy ha nincs kijelölve semmi, akkor az aktuális cellát a CTRL-pont segítségével húzzuk beljebb, és CTRL-vessző segítségével húzhatjuk kijebb.
> | x; |
2. cím
3. cím
4. cím
> | "Ez mar nagyon behuzott"; |
Listák, halmazok, sorozatok
Listáknál számít a sorrend.
> | l:=[5,7,6]; |
Halmazok esetében nem. A visszaadott értéket kell nézni, a 6-os megelőzte a 7-est.
> | h:={5,7,6}; |
A sorozat esetén nem teszünk ki [] és {} jeleket.
> | s:=2,4,3; |
A konverziók a következő képpen működnek:
> | {op(l)};op(l); |
> | [op(h)];op(l); |
> | [s];{s}; |
Továbbá használható még a convert parancs.
> | convert(l,set);convert(h,list); |
Vigyázzunk a sorozatokkal! Ugyanis ha egy függvény hasába tesszük, akkor olyan, mintha bemásoltuk volna az elemeit, mint paramétereket.
> | sin(s); |
Error, (in sin) expecting 1 argument, got 3
Valójában ez a következő sorral ekvivalens. Amire természetesen hibát kapunk, hiszen a sin parancs csak 1 paramétert vár.
> | sin(2,4,3); |
Error, (in sin) expecting 1 argument, got 3
A listák nagy előnye: meg lehet változtatni tetszőleges elemét.
> | l[2]:=1000; |
> | l; |
Listák, sorozatok, halmazok legegyszerűbb létrehozási módja:
> | li:=[seq(i,i=1..10)]; |
> | ha:={seq(i^2,i=1..10)}; |
> | so:=seq(i^3,i=1..10); |
Elemszám vizsgálat:
> | nops(l); |
Elemvizsgálat: A 4 nem eleme az l listának.
> | member(4,l); |
De az 5 már igen!
> | member(5,l); |
Lista növelése 1 taggal:
> | l:=[op(l),-2]; |
Rajzolás, további érdekességek
Egy függvényről az alábbi módon kérhetünk gyors segítséget. Ezt elindítva betölti a help-et. Ugyanazt kapjuk, mint ha a Help-et menüből elindítva keresnénk meg a plot függvényt.
> | ?plot; |
A plot használata úgy vélem egyértelmű.
> | plot(cos(x) + sin(x), x=0..Pi); |
Több függvényt is lehet ábrázolni egy ábrán, ha a függvényeket listába tesszük.
> | plot([x^2,x/2],x=-2..2,y=-1..1); |
Lehetőség van egy görbét rajzolni:
> | plot([5*cos(x),5*sin(x),x=0..3*Pi/2]); |
> | plot([x*cos(x),x*sin(x),x=0..4*Pi]); |
> | temp:=x*y; |
> | eval(temp,[x=3,y=6]); |
> | eqn:=x=y+2; |
> | solve(eqn,y); |
> | f:=x->2*x^2-3*x+5; |
> | plot(f(x),x=-5..5); |
> | lista:=[0,1,1,2]; |
A map parancs segítségével tudunk hattatni egy függvényt egy listára. Ekkor a lista minden elemére kiszámolja a megadott függvény értékét, és ezekből készít egy újabb listát.
> | map(sin,lista); |
> | map(evalf,%); |
Alapvető programok írása
A for hatására az i változó 1-től 10-ig, és minden egyes értékre végrehajtja a "do" és az "od" utasítás közötti részt. Az "od" és az "end do" ugyanazt jelentik, felváltva fogom őket használni. A sorok között nyomjunk SHIFT-ENTER-t, és a legutolsó sornál ENTER-t.
for i from 1 to 10 do
print(i);
od;
Lehetőség van egy lista elemein végigfuttatni az i változót:
> | l:=[1,2,3,4,5,6,7,8,9,20]:
for i in op(l) do print(i); od; |
Első függvényünk. A neve: kiiratas, és egy paramétert fogad el, amely egész (erre utal az integer). A programban a meghívott paramétert "n" változóként érjük el. A programban felhasználunk egy "i" változót, amit nem szeretnénk, hogy a globális "i" változóval összekeverjünk, úgyhogy local i; -vel kezdjük a programot. A proc-ot end-del zárjuk.
> | kiiratas:=proc(n::integer)
local i; for i from 1 to n do print(i); od; end; |
Nagyon fontos: A program bevitele után nem történik semmi. A függvény csak akkor fut le, ha meghívjuk. A meghívást úgy képzeljük el, mintha a program belsejét ide másoltuk volna úgy, hogy mindenhol n értékét kicseréljük 7-re.
> | kiiratas(7); |
Bonyolultabb progam
Először is ismerkedjünk meg a while ciklussal.
while feltétel_amíg_fusson do
parancsok_amik_fussanak;
od;
> | i:=10:
while i < 20 do i:=i+1: print(i); od: |
Véletlen szám:
> | rand(); |
Véletlen szám 0 és 89 között:
> | rand() mod 90; |
Véletlen szám 1 és 90 között:
> | (rand() mod 90)+1; |
if segítségével feltételhez lehet kötni egy programrész futását. Például:
if feltétel then
ha_a_feltétel_teljesül_fusson_le_ez_a_rész;
else
ha_a_feltétel_nem_teljesül_akkor_ez_fusson_le;
fi;
> | if 5 > 6 then
print("5 nagyobb a 6-nál"); else print("Nem is!"); fi; |
A függvénynek két változója van, egy n és k, mindkettő egész. 3 lokális változót használunk. Lottószámot fogunk generálni n szám közül k darabot. A külső for ciklus k-szor fut le, minden egyes alkalommal az "l" lista 1 új elemmel bővül, amely eddig nem volt eleme. A break utasítás hatása: kilép a közvetlenül körülötte lévő ciklusból, és az után folytatódik a futás.
> | lotto:=proc(n::integer,k::integer)
local i,l,x; l:=[]; for i from 1 to k do while true do x:=(rand() mod n) + 1; if member(x,l)=false then break; end if; end do; l:=[op(l),x]; od; {op(l)}; end; |
> | lotto(90,5); |