jsMath

Sage prog

Sage programozása

 

Kezelőfelület:

  • sor végi ENTER -> új sort kezd
  • SHIFT ENTER -> végrehatja az adott cellát
  • Escape -> futtatás megszakítása
  • ctrl ;    -> az adott cellát szétvágja két részre
  • ctrl ENTER    -> az adott cellát szétvágja két részre, és futtatja mindkét darabot
  • ctrl BACKSPACE   -> az adott cellát összevonja az előző cellával
  • alt ENTER -> Futtatj a cellát, majd utána új mezőt nyit
  • a kék csíkra kattintva lehet egérrel új mezőt nyitni (ha közben a SHIFT-et lenyomva tartjuk, akkor olyan megjegyzést írhatunk, mint ez is)
  • a megjegyzézeket dupla kattintással tudjuk megint szerkeszthetővé tenni
  • ha cellán belül egy vagy több sorban kijelölünk részeket (a SHIFT és a nyilak segítségével vagy egérrel), akkor Firefoxban a TAB és SHIFT+TAB hatására változtathatjuk a kijelölt sorok behúzását
  • A eredmények előtt van egy kis fehér rész, ami felett az egér kézzé alakulva jelzi, hogy funkciója van. 3 állapot között lehet váltani: az eredmény normál megjelenítése, egy sorban való kiíratása, vagy az eredmény eltüntetése.
  • Van lehetőség LaTeX kódok írására megjegyzések között:
    ∫0∞sin(x)/x=2π 

 

Segítség a parancsokhoz:

  • help(parancs) + SHIFT ENTER -> egy linket ad, amivel új oldalon nyílik meg a parancs leírása
  • parancs? + SHIFT ENTER -> a parancs leírása
  • parancs? + TAB -> a parancs leírását csak megmutatja
  • paran +TAB -> kiegészíti a parancs nevét, illetve ha ez nem egyértelmű, akkor megadja az opciókat. Az opciók közül nyilakkal választhatunk. Ha ekkor az egyik opción nyomunk mégegy TAB-ot, akkor kiírja a hozzá tartozó leírást.
for i in range(10): print i 
        
0
1
2
3
4
5
6
7
8
9

Sage-ben a szintaxist a Python nyelvből merítették, így a parancsok többsége működik Pythonban is.

Python:

  • Eredeti fejlesztő: Guido van Rossum
  • script nyelv: szükség van egy előre installált környezetre, hogy futni tudjon
  • lassabb, mint ha C/C++, Pascal, Assembly nyelveken doloznánk
  • szinte ugyanaz a kód fut Windows, Linux/Unix, Mac OS, OS/2, Amiga, .Net, Java rendszereken (korlátoltan fut még Symbian-on, PocketPC-n, stb.)
  • cél egy egyszerű, könnyen tanulható, jól olvasható nyelv megalkotása volt
  • batteries included: a legtöbb feladatra elegendő az alap telepítőcsomag

Alapműveletek:
1+10*(2-5) 
        
-29

Egészek hányadosa esetén nem végzi el az osztást, hanem törtként kezeli őket:
5/6 
        
5/6

Ha azonban az egyik szám tizedes tört, akkor tizedes törtként számol tovább:
5.0/6 
        
0.833333333333333

A Sage alapból csak a cella utolsó eredményét írja ki.
2*3 6*7 
        
42

A print függvénnyel tudunk cellán belül eredményt kiíratni:
print 2*3 print 6*7 
        
6
42

Pontosvesszővel is elválaszthatjuk a parancsokat:
print 2*3; print 6*7 
        
6
42
2^5 
        
32

(Pythonban az osztás és a hatványozás kicsit másképp működik.)

Egész osztás és maradékos osztás:
13//4 
        
3
13%4 
        
1

Változók: A változók lehetnek bármilyen angol karaktereket, számokat és _ jelet tartalmazó, betűvel kezdődő név.
a=3 
       
a+2 
        
5

Előző eredmény: _
_ 
        
5

Az értékadás = jellel történik, ilyenkor a bal oldalon nem állhat kifejezés, csak egy változó:
b+3=5 
        
Traceback (click to the left of this block for traceback)
...
SyntaxError: can't assign to operator
b=a 
       
a=4 
       
b 
        
3

A változó szerepelhet az értékadás jobb oldalán is. A jobb oldali kifejezés kiértékelődik, és ez lesz a változó új értéke.
b = b*10 
       
b 
        
30

A

b=b+1

kifejezés rövidítése:
b += 1 
       
b 
        
31
b *= 2 b 
        
62

Lehet egyszerre több értékadást is elvégezni:
q,w = 3,4 
       
q 
        
3
w 
        
4

Két változó cseréje:
q,w = w,q 
       
q 
        
4
w 
        
3

Két változó cseréje külön változóval:
t=q q=w w=t 
       

Logikai műveletek:
13 == 4*(13//4) + 13%4 
        
True
2>3 
        
False

true, True: igaz

false, False: hamis.

and: és

or: vagy

not: nem

<, >, <=, >=, ==, != : kisebb, nagyobb, nem nagyobb, nem kisebb, egyenlő, nem egyenlő
false==False 
        
True
a>=3 and a<10 
        
True
a==3 
        
False
not a==3 
        
True

Szövegek megadásához ' vagy " jelet használjunk. A két jel között nincs különbség.
'abc' 
        
'abc'
"abc" + "def" 
        
'abcdef'
"Teal'c" 
        
"Teal'c"

Listák
[1,2,3,"alma"] 
        
[1, 2, 3, 'alma']

listák összeadása:
[1,2,3,"alma"]+[4,5] 
        
[1, 2, 3, 'alma', 4, 5]
l=[10,20,30,40] 
       
l 
        
[10, 20, 30, 40]

A listák elemszámát a len paranccsal kérdezhetjük meg (length angol szó rövidítése).
len(l) 
        
4

Az i. elemet lista[i] módon érhetjük el. Vigyázat: a sorszámozás 0-tól kezdődik.
l[0] 
        
10
l[1] 
        
20
l[2] 
        
30
l[3] 
        
40
l[4] 
        
Traceback (click to the left of this block for traceback)
...
IndexError: list index out of range

A negatív indexek visszafelé lépkednek a listán:
l[-1] 
        
40
l[-2] 
        
30
l[-3] 
        
20
l[-4] 
        
10
l[-5] 
        
Traceback (click to the left of this block for traceback)
...
IndexError: list index out of range

Van lehetőség a lista elemeit átírni:
l[0] = "barack" 
       
l 
        
['barack', 20, 30, 40]

Részlistát lista[mettől:meddig] módon kérhetünk, ahol a "meddig" számként jelölt elemet már nem adja vissza.
l[0:3] 
        
['barack', 20, 30]
l[1:4] 
        
[20, 30, 40]

A teljes lista:
l[0:len(l)] 
        
['barack', 20, 30, 40]

Nem kell kiírnunk azt az oldalt, amiben nem szeretnénk megkötést.

Az első kivételével a teljes lista:
l[1:] 
        
[20, 30, 40]

Az utolsó kivételével a teljes lista:
l[:-1] 
        
['barack', 20, 30]

A teljes lista:
l[:] 
        
['barack', 20, 30, 40]

Megjegyzés: ezek működnek szöveggel is:
l[1] = u"körte" l 
        
['barack', u'k\xf6rte', 30, 40]
len(l[1]) 
        
5
"abcdef"[2:4] 
        
'cd'

Gyakran előfordul, hogy 0-tól kell kezdenünk egy számolást:
range(10) 
        
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(5,15) 
        
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Használhatjuk a következő jelöléseket:
[0..9] 
        
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[11,13..19] 
        
[11, 13, 15, 17, 19]

A .. köré tehetünk vesszőket is:
[11,13,..,19] 
        
[11, 13, 15, 17, 19]
[1,1.3..3] 
        
[1.00000000000000, 1.30000000000000, 1.60000000000000,
1.90000000000000, 2.20000000000000, 2.50000000000000,
2.80000000000000]

Lekérdezhetjük, hogy egy elem benne van-e a listában:
l 
        
['barack', u'k\xf6rte', 30, 40]
10 in l 
        
False
20 in l 
        
False

for ciklus:

A ciklus végrehajta a kódot úgy, hogy a változót végighelyettesíti a lista elemein.

for változónév in lista:

    végrehajtandó kód bentebb kezdve
for i in [1,2,3]: print i print "négyzete:", i^2 print "ok" 
        
1
négyzete: 1
2
négyzete: 4
3
négyzete: 9
ok

Százig a számok összege:
s=0 for i in [1..100]: s += i s 
        
5050
sum( [1..100] ) 
        
5050
for i in range( len(l) ): print "Az l lista", i, ". eleme:", l[i] 
        
Az l lista 0 . eleme: barack
Az l lista 1 . eleme: körte
Az l lista 2 . eleme: 30
Az l lista 3 . eleme: 40
negyzet=[] for i in [1..10]: negyzet = negyzet+[i^2] negyzet 
        
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

if:

if feltétel:

    végrehajtandó kód, ha a feltétel igaz

else:    (ez a rész opcionális)

    végrehajtandó kód, ha a feltétel hamis
if 2*2 == 4: print "Még minden ok" else: print "Komoly baj van" 
        
Még minden ok

Az is_prime függvény megmondja egy számról, hogy prímszám-e.
is_prime? 
       

File: /home/petya/download/sage-4.8-linux-64bit-ubuntu_10.04.3_lts-x86_64-Linux/local/lib/python2.6/site-packages/sage/rings/arith.py

Type: <type ‘function’>

Definition: is_prime(n)

Docstring:

Returns True if n  is prime, and False otherwise.

AUTHORS:

  • Kevin Stueve kstueve@uw.edu (2010-01-17): delegated calculation to n.is_prime()

INPUT:

  • n - the object for which to determine primality

OUTPUT:

  • bool - True or False

EXAMPLES:

sage: is_prime(389)
True
sage: is_prime(2000)
False
sage: is_prime(2)
True
sage: is_prime(-1)
False
sage: factor(-6)
-1 * 2 * 3
sage: is_prime(1)
False
sage: is_prime(-2)
False

ALGORITHM:

Calculation is delegated to the n.is_prime() method, or in special cases (e.g., Python int``s) to ``Integer(n).is_prime(). If an n.is_prime() method is not available, it otherwise raises a TypeError.
is_prime(17) 
        
True
is_prime(21) 
        
False

100-ig a prímszámok:
for i in [1..100]: if is_prime(i): print i 
        
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

100-ig a prímszámok listában:
l = [] for i in [1..100]: if is_prime(i): l = l+[i] l 
        
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
67, 71, 73, 79, 83, 89, 97]

Van lehetőség egy if elágazáson belül több feltételt is megadni:

if feltétel:

    végrehajtandó kód, ha a feltétel igaz

elif feltétel2:

    végrehajtandó kód, ha a feltétel2 igaz

...

else:    (ez a rész opcionális)

    végrehajtandó kód, ha az összes feltétel hamis
x=2 if x > 0: print "x pozitív" elif x < 0: print "x negatív" else: print "x nulla" 
        
x pozitív
x=2 if x > 0: print "x pozitív" else: if x < 0: print "x negatív" else: print "x nulla" 
        
x pozitív

while ciklus:

A while ciklus használata egyszerűbb, mint a for ciklusé. Addig fut, amíg a feltétel igaz. Pontosan: minden körben leellenőrzi, hogy a feltétel igaz-e. Ha igen, akkor lefut a megadott kód mégegyszer.

while feltétel:

    végrehajtandó kód
n=0 while n < 10: print n n += 1 
        
0
1
2
3
4
5
6
7
8
9
n 
        
10
n=1000 while not is_prime(n) or not is_prime(n+2): n += 1 print "Találtam ikerprímet:",n,n+2 
        
Találtam ikerprímet: 1019 1021

break:

A for és while ciklusokon belül kiadott break leállítja a ciklus futását (egészen pontosan a legbelső for/while ciklus futását amennyiben több ciklus van egymásba ágyazva).
n=1 while True: if is_prime(n) and is_prime(n+6): break n=n+1 n 
        
5
for i in [1..10]: print i if is_prime(i): break 
        
1
2

Függvények írása:

def függvénynév(paraméterek):

    kód

    return visszatérési érték
def egymegegy(): return 2 
       

Ha a return-t kicserélnénk print-re, akkor is kiírná az eredményt a függvény meghívasok, ám nem tudnánk egy változóban elmenteni.
egymegegy() 
        
2
v = egymegegy() 
       
v 
        
2

n-ig a számok összege:
def osszeg(n): s = 0 for i in [1..n]: s += i return s 
       
osszeg(100) 
        
5050

n-ig a talált prímek száma:
def primek(n): talalt = 0 for i in [1..n]: if is_prime(i): talalt += 1 return talalt 
       
primek(100) 
        
25

Listát megfordító eljárás:
l=[1,2,3] uj = [] for k in l: uj = [k] + uj uj 
        
[3, 2, 1]
def fordit(w): uj = [] for k in w: uj = [k] + uj return uj 
       
fordit([1,2,3]) 
        
[3, 2, 1]
fordit(["alma","barack","kiwi",42]) 
        
[42, 'kiwi', 'barack', 'alma']
l = [1,2,3] 
       
l.reverse() 
       
l 
        
[3, 2, 1]

A next_prime(n) függvény kiírja az n-et követő első prímet. Ilyet mi is könnyen tudunk írni:
next_prime(10) 
        
11

A return után végetér a függvény futása.
def kov_prim(n): while True: n+=1 if is_prime(n): return n 
       
kov_prim(10) 
        
11

Írjunk faktoriálist kiszámoló programot!
def fakt(n): if n == 0: return 1 return n*fakt(n-1) 
       
fakt(5) 
        
120

Az átláthatóság kedvéért el is tüntethetjük a kódot, ha az első sorba %hide parancsot írunk:
%hide def rejtett_fakt(n): if n == 0: return 1 return n*rejtett_fakt(n-1) 
       
magat_elindito_fakt(6) 
        
720

A függvényünk csak akkor működik, ha a legalább egyszer lefuttatjuk. Ezt a Sage is megcsinálja helyettünk a betöltéskor, ha %auto -val kezdjük a cellát:
%auto def magat_elindito_fakt(n): if n == 0: return 1 return n*magat_elindito_fakt(n-1) 
       

Az alábbi sor minden megnyitás után más véletlenszámot ad:
%auto random() 
        
0.97156838714451421

Listák:

Egy lista elemként tartalmazhat bármit, akár egy másik listát is.
[1,"alma",[1,2],[[]],[[],[]],[[[]]]] 
        
[1, 'alma', [1, 2], [[]], [[], []], [[[]]]]
l=[[1,2],[8,9]] 
       
l 
        
[[1, 2], [8, 9]]
l[0] 
        
[1, 2]
l[0][1] 
        
2
for i in l: print i[0]+i[1] 
        
3
17

Listákat nagyon könnyen előállíthatunk a következő módon:

[képlet for változó in lista]
[i for i in [1..10]] 
        
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[8 for i in [1..10]] 
        
[8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
[i^2 for i in [1..10]] 
        
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
list_plot([1,2,7,8]) 
       
[sin(i) for i in [0,0.2,..2*pi]] 
        
[0, 0.198669330795061, 0.389418342308651, 0.564642473395035,
0.717356090899523, 0.841470984807897, 0.932039085967226,
0.985449729988460, 0.999573603041505, 0.973847630878195,
0.909297426825682, 0.808496403819590, 0.675463180551151,
0.515501371821464, 0.334988150155905, 0.141120008059867,
-0.0583741434275805, -0.255541102026832, -0.442520443294853,
-0.611857890942720, -0.756802495307929, -0.871575772413589,
-0.951602073889516, -0.993691003633465, -0.996164608835841,
-0.958924274663138, -0.883454655720152, -0.772764487555986,
-0.631266637872320, -0.464602179413755, -0.279415498198923,
-0.0830894028174937]
list_plot([sin(i) for i in [0,0.2,..2*pi]]) 
       

Lehetőségünk van még plusz feltételt írni. Csak a feltételt teljesítő elemek kerülnek be a listába.

[képlet for változó in lista if feltétel]

100-ig a prímek:
[i for i in [1..100] if is_prime(i)] 
        
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
67, 71, 73, 79, 83, 89, 97]

Az utolsó 3 prím 100 előtt:
[i for i in [1..100] if is_prime(i)][-3:] 
        
[83, 89, 97]
[fibonacci(i) for i in [1..20]] 
        
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987,
1597, 2584, 4181, 6765]
for x in [fibonacci(i) for i in [1..20]]: print "A következő Fibonacci szám:",x,"melynek felbontása",factor(x) 
        
A következő Fibonacci szám: 1 melynek felbontása 1
A következő Fibonacci szám: 1 melynek felbontása 1
A következő Fibonacci szám: 2 melynek felbontása 2
A következő Fibonacci szám: 3 melynek felbontása 3
A következő Fibonacci szám: 5 melynek felbontása 5
A következő Fibonacci szám: 8 melynek felbontása 2^3
A következő Fibonacci szám: 13 melynek felbontása 13
A következő Fibonacci szám: 21 melynek felbontása 3 * 7
A következő Fibonacci szám: 34 melynek felbontása 2 * 17
A következő Fibonacci szám: 55 melynek felbontása 5 * 11
A következő Fibonacci szám: 89 melynek felbontása 89
A következő Fibonacci szám: 144 melynek felbontása 2^4 * 3^2
A következő Fibonacci szám: 233 melynek felbontása 233
A következő Fibonacci szám: 377 melynek felbontása 13 * 29
A következő Fibonacci szám: 610 melynek felbontása 2 * 5 * 61
A következő Fibonacci szám: 987 melynek felbontása 3 * 7 * 47
A következő Fibonacci szám: 1597 melynek felbontása 1597
A következő Fibonacci szám: 2584 melynek felbontása 2^3 * 17 * 19
A következő Fibonacci szám: 4181 melynek felbontása 37 * 113
A következő Fibonacci szám: 6765 melynek felbontása 3 * 5 * 11 * 41

Az n-ig található prímek számának meghatározására írtunk egy primek függvényt:
def primek(n): talalt = 0 for i in [1..n]: if is_prime(i): talalt += 1 return talalt 
       

Felhasználva ezt a módszert, ez megírható egyszerűbben:
def primek2(n): return len( [i for i in [1..n] if is_prime(i)] ) 
       
primek2(100) 
        
25

2000 prímtényezős felbontása:
factor(2000) 
        
2^4 * 5^3

Írjuk ki 2000 pozitív osztóit!

Azaz minden osztója 2^k * 5^l alakú, ahol k=0,1,2,3,4 és l=0,1,2,3. Ezt könnyen megoldhatjuk dupla for használatával:
[2^k * 5^l for k in [0..4] for l in [0..3]] 
        
[1, 5, 25, 125, 2, 10, 50, 250, 4, 20, 100, 500, 8, 40, 200, 1000,
16, 80, 400, 2000]

Szorzótábla:
[ [i*j for i in [1..5]] for j in [1..5]] 
        
[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12,
16, 20], [5, 10, 15, 20, 25]]