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;

2

> 1+1:

> 15!;

1307674368000

> 15!:

Amennyiben túl hosszú a beírt sor, akkor nem írja ki.

> 15000!;

27465990334851682664825581502626675377669983302658241873984787525304521079312253274085307332114446509830257090495822324265168899760335148841707118823471594703909649496852027862912498376364295133481754...27465990334851682664825581502626675377669983302658241873984787525304521079312253274085307332114446509830257090495822324265168899760335148841707118823471594703909649496852027862912498376364295133481754...27465990334851682664825581502626675377669983302658241873984787525304521079312253274085307332114446509830257090495822324265168899760335148841707118823471594703909649496852027862912498376364295133481754...

Fontos, hogy minden egyes parancsnál számít a nagy és kisbetű.

> Pi;

Pi

> 1+3/2;

5/2

> 2+Pi/2;

2+1/2*Pi

Nincs olyan beépített parancs, hogy Sin, nagy S-sel.

> Sin(Pi);

Sin(Pi)

> sin(Pi);

0

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);

3.141592654

> evalf(sin(1));

.8414709848

Állítható a számolandó pontosság:

> evalf(Pi,30);

3.14159265358979323846264338328

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;

Digits := 20

> evalf(Pi);

3.1415926535897932385

Előző parancs futásának eredménye: %

> 2*%;

6.2831853071795864770

Értékadás :=

> x:=3;

x := 3

> alpha:=5;

alpha := 5

> x;

3

Értéket így törölhetünk:

> x:='x';

x := x

> x;

x

Prímtényezőkre bontás:

> ifactor(60);

``(2)^2*``(3)*``(5)

Legnagyobb közös osztó:

> igcd(120,20);

20

> isprime(18002676583);

true

> sqrt(2);

2^(1/2)

> sqrt(2)^2;

2

Modulo legkisebb abszolútértékű maradékkal:

> mods(27,4);

-1

> modp(27,4);

3

> 27 mod 4;

3

> Diff(sin(x),x);

Diff(sin(x), x)

> value(%);

cos(x)

> sum(n^2,n=1..k);

1/3*(k+1)^3-1/2*(k+1)^2+1/6*k+1/6

> sum(1/n^2,n=1..infinity);

1/6*Pi^2

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;

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];

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};

h := {5, 6, 7}

A sorozat esetén nem teszünk ki [] és {} jeleket.

> s:=2,4,3;

s := 2, 4, 3

A konverziók a következő képpen működnek:

> {op(l)};op(l);

{5, 6, 7}

5, 7, 6

> [op(h)];op(l);

[5, 6, 7]

5, 7, 6

> [s];{s};

[2, 4, 3]

{2, 3, 4}

Továbbá használható még a convert parancs.

> convert(l,set);convert(h,list);

{5, 6, 7}

[5, 6, 7]

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[2] := 1000

> l;

[5, 1000, 6]

Listák, sorozatok, halmazok legegyszerűbb létrehozási módja:

> li:=[seq(i,i=1..10)];

li := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

> ha:={seq(i^2,i=1..10)};

ha := {1, 4, 9, 16, 25, 36, 49, 64, 81, 100}

> so:=seq(i^3,i=1..10);

so := 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000

Elemszám vizsgálat:

> nops(l);

3

Elemvizsgálat: A 4 nem eleme az l listának.

> member(4,l);

false

De az 5 már igen!

> member(5,l);

true

Lista növelése 1 taggal:

> l:=[op(l),-2];

l := [5, 1000, 6, -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);

[Plot]

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);

[Plot]

Lehetőség van egy görbét rajzolni:

> plot([5*cos(x),5*sin(x),x=0..3*Pi/2]);

[Plot]

> plot([x*cos(x),x*sin(x),x=0..4*Pi]);

[Plot]

> temp:=x*y;

temp := x*y

> eval(temp,[x=3,y=6]);

18

> eqn:=x=y+2;

eqn := x = y+2

> solve(eqn,y);

x-2

> f:=x->2*x^2-3*x+5;

f := proc (x) options operator, arrow; 2*x^2-3*x+5 end proc

> plot(f(x),x=-5..5);

[Plot]

> lista:=[0,1,1,2];

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);

[0, sin(1), sin(1), sin(2)]

> map(evalf,%);

[0., .8414709848, .8414709848, .9092974268]

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;

1

2

3

4

5

6

7

8

9

10

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;

1

2

3

4

5

6

7

8

9

20

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;

kiiratas := proc (n::integer) local i; for i to n do print(i) end do end proc

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);

1

2

3

4

5

6

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:

11

12

13

14

15

16

17

18

19

20

Véletlen szám:

> rand();

259811952655

Véletlen szám 0 és 89 között:

> rand() mod 90;

87

Véletlen szám 1 és 90 között:

> (rand() mod 90)+1;

81

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 := proc (n::integer, k::integer) local i, l, x; l := []; for i to k do do x := `mod`(rand(), n)+1; if member(x, l) = false then break end if end do; l := [op(l), x] end do; {op(l)} end proclotto := proc (n::integer, k::integer) local i, l, x; l := []; for i to k do do x := `mod`(rand(), n)+1; if member(x, l) = false then break end if end do; l := [op(l), x] end do; {op(l)} end proclotto := proc (n::integer, k::integer) local i, l, x; l := []; for i to k do do x := `mod`(rand(), n)+1; if member(x, l) = false then break end if end do; l := [op(l), x] end do; {op(l)} end proclotto := proc (n::integer, k::integer) local i, l, x; l := []; for i to k do do x := `mod`(rand(), n)+1; if member(x, l) = false then break end if end do; l := [op(l), x] end do; {op(l)} end proclotto := proc (n::integer, k::integer) local i, l, x; l := []; for i to k do do x := `mod`(rand(), n)+1; if member(x, l) = false then break end if end do; l := [op(l), x] end do; {op(l)} end proclotto := proc (n::integer, k::integer) local i, l, x; l := []; for i to k do do x := `mod`(rand(), n)+1; if member(x, l) = false then break end if end do; l := [op(l), x] end do; {op(l)} end proclotto := proc (n::integer, k::integer) local i, l, x; l := []; for i to k do do x := `mod`(rand(), n)+1; if member(x, l) = false then break end if end do; l := [op(l), x] end do; {op(l)} end proclotto := proc (n::integer, k::integer) local i, l, x; l := []; for i to k do do x := `mod`(rand(), n)+1; if member(x, l) = false then break end if end do; l := [op(l), x] end do; {op(l)} end proc

> lotto(90,5);

{6, 32, 39, 69, 80}