Komputeralgebra Rendszerek

Komputeralgebra Rendszerek Elemi programozás Czirbusz Sándor ELTE IK, Komputeralgebra Tanszék 2017. február 27. TARTALOMJEGYZÉK 1 of 70

TARTALOMJEGYZÉK I 1 MAPLE Értékadás Feltételes utasítás Ciklusok Általános ciklusok Függvények Funkcionális programozás 2 SAGE Értékadás Feltételes utasítás Ciklusok Függvények 3 MATHEMATICA Értékadás Függvények Vezérlési struktúrák Funkcionális programozás Lokális változók TARTALOMJEGYZÉK 2 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); MAPLE 3 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) MAPLE 4 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): MAPLE 5 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): name := name MAPLE 6 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): name := name unassign( name1, name2,... ) MAPLE 7 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): name := name unassign( name1, name2,... ) evaln( name ); MAPLE 8 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): name := name unassign( name1, name2,... ) evaln( name ); Az assign utasítás: assign(a,b), assign(a=b), assign(l): mindkét oldal kiértékelése MAPLE 9 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): name := name unassign( name1, name2,... ) evaln( name ); Az assign utasítás: assign(a,b), assign(a=b), assign(l): mindkét oldal kiértékelése a,b paraméterek: a = b (egyszerű változókra) MAPLE 10 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): name := name unassign( name1, name2,... ) evaln( name ); Az assign utasítás: assign(a,b), assign(a=b), assign(l): mindkét oldal kiértékelése a,b paraméterek: a = b (egyszerű változókra) A,B paraméterek: A,B azonos hosszú kifejezés-sorozat MAPLE 11 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): name := name unassign( name1, name2,... ) evaln( name ); Az assign utasítás: assign(a,b), assign(a=b), assign(l): mindkét oldal kiértékelése a,b paraméterek: a = b (egyszerű változókra) A,B paraméterek: A,B azonos hosszú kifejezés-sorozat L paraméter: L egyenletek listája vagy halmaza; MAPLE 12 of 70

AZ ÉRTÉKADÁS MAPLE-BEN name := expr; (name1,..., namen) := (expr1,..., exprn); Tesztelés: assigned(name) Hozzárendelés visszavonása (a szimbólum azért marad): name := name unassign( name1, name2,... ) evaln( name ); Az assign utasítás: assign(a,b), assign(a=b), assign(l): mindkét oldal kiértékelése a,b paraméterek: a = b (egyszerű változókra) A,B paraméterek: A,B azonos hosszú kifejezés-sorozat L paraméter: L egyenletek listája vagy halmaza; MAPLE 13 of 70

AZ ASSIGN-RÓL RÖVIDEN solve(3 x + 17 a = 1, {x}) { } x = 1/3 17 a 3 assign ( % ) x 1/3 17 a 3 x := x : c := c : x := c assign ( x = 23) x 23 c 23 MAPLE 14 of 70

KIÉRTÉKELÉS Teljes kiértékelés: az általános kiértékelési stratégia; MAPLE 15 of 70

KIÉRTÉKELÉS Teljes kiértékelés: az általános kiértékelési stratégia; utolsó név kiértékelés: függvények, a linalg csomag tömbjei MAPLE 16 of 70

FELTÉTELES UTASÍTÁS I if cond1 then statement_sequ1 elif cond2 then statement_sequ2 elif cond3 then statement_sequ3............ else statement_sequn end if MAPLE 17 of 70

FELTÉTELES UTASÍTÁS II Feltételes kifejezések konstruálása és kiértékelése: Relációs műveletek: <, <=, =, >=, >, <> Logikai műveletek - and, or, xor, implies, not Logikai nevek- true, false, FAIL Kiértékelés: evalb, testeq, vagy is Megjegyzés A logika logika háromértékű: true, false és FAIL MAPLE 18 of 70

FOR...FROM CIKLUS for counter from i n i t by increment to f i n a l do statement_seq end do A from, a by és a to klauza opcionális, sorrendjük tetszőleges. A default értékek: by =1, from = 0. MAPLE 19 of 70

FOR/IN CIKLUS for v a r i a b l e in expr do statement_seq end do Az "expr" (iterálható struktúra) minden komponesén végigszalad a változó és végrehajtja az utasításokat. Ilyen pl a PHP foreach ciklusa. MAPLE 20 of 70

WHILE CIKLUS while cond do statement_seq end do MAPLE 21 of 70

ÁLTALÁNOS CIKLUSOK for counter from i n i t by increment to f i n a l while cond do statement_seq end do for v a r i a b l e in expr while cond do statement_seq end do Ciklusfutás befolyásolása: break,next MAPLE 22 of 70

MATEMATIKAI FÜGGVÉNYEK https://www.maplesoft.com/support/help/maple/ view.aspx?path=initialfunctions MAPLE 23 of 70

FORMULÁVAL Nem igazi függvény! Értékadás: T := T0 exp( c t) MAPLE 24 of 70

FORMULÁVAL Nem igazi függvény! T := T0 exp( c t) Értékadás: subs vagy az eval segítségével MAPLE 25 of 70

FORMULÁVAL Nem igazi függvény! T := T0 exp( c t) Értékadás: subs vagy az eval segítségével Eval és value segítségével MAPLE 26 of 70

EGYSZERŰ FÜGGVÉNYDEFINIÁLÁS Nyíl operátor fn := parameter(ek)-> kif MAPLE 27 of 70

EGYSZERŰ FÜGGVÉNYDEFINIÁLÁS Nyíl operátor fn := parameter(ek)-> kif Többváltozós is és 0 változós is lehet MAPLE 28 of 70

EGYSZERŰ FÜGGVÉNYDEFINIÁLÁS Nyíl operátor fn := parameter(ek)-> kif Többváltozós is és 0 változós is lehet paraméteres függvény megadására nem alkalmas MAPLE 29 of 70

EGYSZERŰ FÜGGVÉNYDEFINIÁLÁS Nyíl operátor fn := parameter(ek)-> kif Többváltozós is és 0 változós is lehet paraméteres függvény megadására nem alkalmas Röptében Az f(x) := kifejezés forma az újabb MAPLE-verziókban működik, a rendszer megkérdezi, valóban függvényt akarunk-e definiálni. MAPLE 30 of 70

DEFINIÁLÁS I proc ( parameter_seq \ ) [ : : r e t _ t y p e ] [ l o c a l name_seq ; [ global name_seq ; ] [ options name_seq ; ] [ d e s c r i p t i o n s t r i n g ; ] [ uses name_seq ; ] statements [ return expr ] end proc % % Paraméterek típusegyeztetése a :: -vel Visszaadott érték ha nincs explict return utasítás: az utoljára számított. A proc operandusai MAPLE 31 of 70

DEFINIÁLÁS II op 1 A paramétersorozat op 2 A lokális változók op 3 Az opciók op 4 A remember táblázat op 5 A leíró rész op 6 A globális változók op 7 Lexikális tábla (a nemdefiniált változók kapcsolata környező proc-okkal) op 8 A visszaadott érték típusa, ha definiált MAPLE 32 of 70

DEFINIÁLÁS III Tesztelgetés kernelopts(profile=true) - a procedúrahívások figyelése exprofile, excallgraph A remember listázása: interface(verboseproc=3), print (proc) op(4,eval(proc)) Törlés: forget(proc,[n]). Mellékhatás: a proc/nevű procedúrák táblái is törlődnek. Alternatív törlés: subsop MAPLE 33 of 70

REKURZIÓ A remember táblázat. Az option remember hatására építi föl MAPLE 34 of 70

REKURZIÓ A remember táblázat. Az option remember hatására építi föl Lekérdezhető: a procedúra struktúra 4. eleme: op(4, eval(procname)); MAPLE 35 of 70

REKURZIÓ A remember táblázat. Az option remember hatására építi föl Lekérdezhető: a procedúra struktúra 4. eleme: op(4, eval(procname)); Felülírható: procname(arg): = value; MAPLE 36 of 70

REKURZIÓ A remember táblázat. Az option remember hatására építi föl Lekérdezhető: a procedúra struktúra 4. eleme: op(4, eval(procname)); Felülírható: procname(arg): = value; Törölhető: forget(procname, index) MAPLE 37 of 70

MŰVELETEK FÜGGVÉNYEKKEL Elemi műveletek: összeadás, szorzás, stb. MAPLE 38 of 70

MŰVELETEK FÜGGVÉNYEKKEL Elemi műveletek: összeadás, szorzás, stb. Kompozíció Általában f@g, önmagával (f@@n), inverz: f@@(-1) MAPLE 39 of 70

FUNKCIONÁLIS PROGRAMOZÁS A MAPLE-BEN map: map ( f, [ 1 0, 2 0, 3 0, 4 0 ] ) [ f ( 1 0 ), f ( 2 0 ), f ( 3 0 ), f ( 4 0 ) ] map2: map2 ( f, 0, [ 1 0, 20, 30, 4 0 ] ) [ f ( 0, 1 0 ), f ( 0, 2 0 ), f ( 0, 3 0 ), f ( 0, 4 0 ) ] map[n]: map [ 6 ] ( f, 0, 1, 2, 3, 4, [ 1 0, 20, 30, 4 0 ] ) [ f ( 0, 1, 2, 3, 4, 1 0 ), f ( 0, 1, 2, 3, 4, 2 0 ), f ( 0, 1, 2, 3, 4, 3 0 ), f ( 0, 1, 2, 3, 4, 4 0 ) ] zip: zip ( ( x, y ) > x+y, [ 1, 2, 3 ], [ 4, 5, 6 ] ) [ 5, 7, 9] curry, curryr: g := curry ( f, 1 ) : g ( y, z ) f ( 1, y, z ) MAPLE 40 of 70

AZ ÉRTÉKADÁS SAGE-BEN Az x változót kivéve kötelező a [varlist] = var( [varlist] ) deklaráció, ez egyben a meglévő változók értékeit meg is szünteti; SAGE 41 of 70

AZ ÉRTÉKADÁS SAGE-BEN Az x változót kivéve kötelező a [varlist] = var( [varlist] ) deklaráció, ez egyben a meglévő változók értékeit meg is szünteti; a SAGE eredeti notebook-jában van egy automatic_names(true) opció, de ez nincs az SMC-ben; SAGE 42 of 70

AZ ÉRTÉKADÁS SAGE-BEN Az x változót kivéve kötelező a [varlist] = var( [varlist] ) deklaráció, ez egyben a meglévő változók értékeit meg is szünteti; a SAGE eredeti notebook-jában van egy automatic_names(true) opció, de ez nincs az SMC-ben; értékadás: var = kif; SAGE 43 of 70

AZ ÉRTÉKADÁS SAGE-BEN Az x változót kivéve kötelező a [varlist] = var( [varlist] ) deklaráció, ez egyben a meglévő változók értékeit meg is szünteti; a SAGE eredeti notebook-jában van egy automatic_names(true) opció, de ez nincs az SMC-ben; értékadás: var = kif; ugyanúgy megy a var1, var2,... = kif1, kif2,... forma is. Azonos számú változó és kifejezést esetén mindegyik változóba a megfelelő érték kerül; SAGE 44 of 70

AZ ÉRTÉKADÁS SAGE-BEN Az x változót kivéve kötelező a [varlist] = var( [varlist] ) deklaráció, ez egyben a meglévő változók értékeit meg is szünteti; a SAGE eredeti notebook-jában van egy automatic_names(true) opció, de ez nincs az SMC-ben; értékadás: var = kif; ugyanúgy megy a var1, var2,... = kif1, kif2,... forma is. Azonos számú változó és kifejezést esetén mindegyik változóba a megfelelő érték kerül; ha csak egy változó és több kifejezés van, akkor a változóba egy tuple kerül (rendezett konstans lista); SAGE 45 of 70

AZ ÉRTÉKADÁS SAGE-BEN Az x változót kivéve kötelező a [varlist] = var( [varlist] ) deklaráció, ez egyben a meglévő változók értékeit meg is szünteti; a SAGE eredeti notebook-jában van egy automatic_names(true) opció, de ez nincs az SMC-ben; értékadás: var = kif; ugyanúgy megy a var1, var2,... = kif1, kif2,... forma is. Azonos számú változó és kifejezést esetén mindegyik változóba a megfelelő érték kerül; ha csak egy változó és több kifejezés van, akkor a változóba egy tuple kerül (rendezett konstans lista); működnek a C tipusú inkrementálások SAGE 46 of 70

FELTÉTELES UTASÍTÁS if cond1 : statement_sequ1 elif cond2 : statement_sequ2 elif cond3 : statement_sequ3............ else : statement_sequn Nincs blokkvége, a kettőspont kötelező SAGE 47 of 70

FELTÉTELES KIFEJEZÉSEK KONSTRUÁLÁSA Feltételvizsgálat: kif1 == kif2 vagy kif1 is kif2 SAGE 48 of 70

FELTÉTELES KIFEJEZÉSEK KONSTRUÁLÁSA Feltételvizsgálat: kif1 == kif2 vagy kif1 is kif2 Logikai operátorok: and, or, not SAGE 49 of 70

FELTÉTELES KIFEJEZÉSEK KONSTRUÁLÁSA Feltételvizsgálat: kif1 == kif2 vagy kif1 is kif2 Logikai operátorok: and, or, not A logikai kiértékelések természetesebbek a MAPLE-énál SAGE 50 of 70

A FOR ITERÁCIÓ I for counter in range : statement_seq A range paraméterei a szokásos kezdőérték (a default 0), végérték és léptetés (default = 1). A más nyelvekben szokásostól, a végértékre már nem fut le a ciklus, mert itt futások számát jelenti. Variánsai: range : egy listát állít elő xrange : nem listat készít, hanem iterátort, ezért gyorsabb srange : a leglassab, szintén listát készít, továbbparaméterezhető SAGE 51 of 70

A FOR ITERÁCIÓ II for counter in obj : statement_seq Itt az obj egy iterálható objektum, többnyire lista. A kettőspont itt is kötelező, a ciklustörzs adig tart, míg ki nem lépünk az indentálásból. SAGE 52 of 70

A WHILE CIKLUS while l o g i k a i _ f e l t : statement_seq A szokásos while szerkezet a Pythonos-szintaxissal. SAGE 53 of 70

MATEMATIKAI FÜGGVÉNYEK http://sagemath.wikispaces.com/functions+math SAGE 54 of 70

A LAMBDA FÜGGVÉNY add_zz = lambda a, b : a + b SAGE 55 of 70

A SAGE PROCEDÚRÁI Python örökség: a struktúrát csak az indentálás jelzi. SAGE 56 of 70

A SAGE PROCEDÚRÁI Python örökség: a struktúrát csak az indentálás jelzi. A def fn(paraméterek): után a bekezdés 4 karakterrel beljebb kerül. SAGE 57 of 70

A SAGE PROCEDÚRÁI Python örökség: a struktúrát csak az indentálás jelzi. A def fn(paraméterek): után a bekezdés 4 karakterrel beljebb kerül. """ a docstring SAGE 58 of 70

A SAGE PROCEDÚRÁI Python örökség: a struktúrát csak az indentálás jelzi. A def fn(paraméterek): után a bekezdés 4 karakterrel beljebb kerül. """ a docstring A procedúratörzs addig tart, míg ezt az indentálást megszüntetjük (vagyis visszakerülünk a def első betűje oszlopába). SAGE 59 of 70

A SAGE PROCEDÚRÁI Python örökség: a struktúrát csak az indentálás jelzi. A def fn(paraméterek): után a bekezdés 4 karakterrel beljebb kerül. """ a docstring A procedúratörzs addig tart, míg ezt az indentálást megszüntetjük (vagyis visszakerülünk a def első betűje oszlopába). Bárhol elhelyezett return megszakítja a procedúrát SAGE 60 of 70

A SAGE PROCEDÚRÁI Python örökség: a struktúrát csak az indentálás jelzi. A def fn(paraméterek): után a bekezdés 4 karakterrel beljebb kerül. """ a docstring A procedúratörzs addig tart, míg ezt az indentálást megszüntetjük (vagyis visszakerülünk a def első betűje oszlopába). Bárhol elhelyezett return megszakítja a procedúrát Visszatérést okoz a yield is; ekkor iterátort gyártunk SAGE 61 of 70

FUNKCIONÁLIS PROGRAMOZÁS Egy példa: from operator import add L = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] reduce ( add, L ) 55 sum ( L ) 55 SAGE 62 of 70

ÉRTÉKADÁS Azonnali értékadás: 1 x=v 2 {x,y}={u,v} 3 {x,y}={y,x} C tipusú étékadás: 1 x-- (Decrement) 2 x*=y (TimesBy) 3 ++x (PreIncrement) 4 --x (PreDecrement) 5 x/=y (DivideBy) 6 x+=y (AddTo) 7 x-=y (SubtractFrom) MATHEMATICA 63 of 70

MATEMATIKAI FÜGGVÉNYEK http://reference.wolfram.com/language/guide/ MathematicalFunctions.html http://reference.wolfram.com/language/guide/ GeneralizedFunctions.html Szintaxis: a függvény neve nagybetűs, kerek zárójel helyett szögletes MATHEMATICA 64 of 70

SAJÁT FÜGGVÉNYEK 1 In[1] := f[x_]:=x 2 + 1 2 In[2] := f[100] 3 Out[2] := 101 4 5 In[3] := f[x_,y_] := x y 2 6 In[4] := f[2] 7 Out[4] := 5 8 In[5] := f[4,7] 9 Out[5] := 4 49 MATHEMATICA 65 of 70

CIKLUSOK I Do[expr,{i,imax}] az expr kiértékelése 1-től imax-ig egyesével; Do[expr,{i,imin,imax,di}] az expr kiértékelése imin-től imax-ig egyesével di növekménnyel; Do[expr,{i,list}] az expr kiértékelése, i értékei list-ből vannak; Do[expr,{n}] az expr kiértékelése n-szer; MATHEMATICA 66 of 70

CIKLUSOK II While[test,body] body kiértékelése, amíg test igaz; For[start,test,incr,body] start kiértékelése, majd body és incr kiértékelése, míg test igaz; Break[], Continue[]; Return[expr]; Goto[name] MATHEMATICA 67 of 70

ELÁGAZÁSOK 1 In[1] := odd[n_] := If[x > 0, x 2, x 2 ] 2 In[2] := odd[-3] 3 Out[1] := -9 4 5 In[3]: myfn[_x]:= If[x==1,1 Sin[x] x ] 6 7 In[4] :=factorial[n_] := (temp :=1; 8 Do[temp = temp * counter, {counter, 1, n}]; 9 temp 10 ) 11 In[5]:= factorial[5] 12 Out[2] := 720 13 In[6] := temp 14 Out[6] := 720 MATHEMATICA 68 of 70

RELÁCIÓK ÉS LOGIKAI OPERÁTOROK x==y; x!=y; x>y; x>=y; x<y; x<=y!p; p&&q&&... ; p q...; Xor[p,q,...]; Nand[p,q,...], Nor[p,q,...] MATHEMATICA 69 of 70

FUNKCIONÁLIS PROGRAMOZÁS 1 In[1] := Clear[f] 2 In[2] := Map[f, {100,200,300}] 3 Out[1] := {f[100], f[200], f[300]} 4 5 In[3] := NestList[f, 100,3] 6 Out[2] := {100, f[100],f[f[100]],f[f[f[100]]]} MATHEMATICA 70 of 70

LOKÁLIS VÁLTOZÓK 1 In[1] :=factorial[n_] := Module[{temp},(temp :=1; 2 Do[temp = temp * counter, {counter, 1, n}]; 3 temp] 4 ) MATHEMATICA 71 of 70