MPZI_predavanje_10 -- Sage

Nazivi, varijable, tipovi

Nazivi

Naziv ili ime je niz znakova koji označava varijablu, funkciju, tip ili razred.

Pravila oblikovanja naziva:

mogu se upotrebljavati mala i velika slova engleske abecede 'a'...'z' i 'A'...'Z' (bez dijakritičkih znakova 'č', 'ć', 'đ', 'š', 'ž', 'ä', 'ë', 'ö', 'ü', ...), znamenke '0'...'9' i podvlaka '_',
prvi znak mora biti slovo ili podvlaka.

Primjeri ispravno oblikovanih naziva: seven, sedam, _7, __, the_girl_who_cried_champagne, TheGirlWhoCriedChampagne

Primjeri neispravnih naziva: 7_, C++, C#, četvrtak, The Girl Who Cried Champagne, the-girl-who-cried-champagne

Velika i mala slova se razlikuju, tako da su utviklingssang, Utviklingssang i UTVIKLINGSSANG tri različita naziva.

Varijable i pridruživanje

Varijabla je područje u memoriji računala kojem se može pristupiti navođenjem njezina naziva, a i nekih drugih izraza, poput indeksiranja u listi.

Varijable sadrže vrijednosti. Te se vrijednosti mogu mijenjati. Vrijednost se u varijablu upisuje ili „pohranjuje” pridruživanjem:

a = 13
a

Operator = je operator pridruživanja, a ne ispitivanja jednakosti.

Naziv varijable može se pojaviti i s lijeve i s desne strane znaka pridruživanja, ali se značenja njezina naziva u ta dva slučaja razlikuju. S lijeve strane naziv označava područje u memoriji u koje se upisuje vrijednost izraza koji je s desne strane. S desne pak strane znaka pridruživanja naziv označava sadržaj varijable—vrijednost koja je u njoj pohranjena.

b = a
b

Naziv varijable se ne smije pojaviti s desne strane znaka pridruživanja prije no što je u varijablu upisana vrijednost.

b = c

Traceback (click to the left of this block for traceback)
...
NameError: name 'c' is not defined

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "_sage_input_9.py", line 10, in <module>
    exec compile(u"print _support_.syseval(python, u'b = c', __SAGE_TMP_DIR__)" + '\n', '', 'single')
  File "", line 1, in <module>
    
  File "/usr/lib/sagemath/local/lib/python2.7/site-packages/sagenb/misc/support.py", line 438, in syseval
    return system.eval(cmd, sage_globals, locals = sage_globals)
  File "/usr/lib/sagemath/local/lib/python2.7/site-packages/sage/misc/python.py", line 63, in eval
    eval(z, globals)
  File "", line 1, in <module>
    
NameError: name 'c' is not defined

c = a + 1
b = c
b

Izraz koji označava varijablu naziva se lvalue (left hand value), dok se izraz koji označava vrijednost koja jest ili može biti sadržaj varijable naziva rvalue (right hand value).

Naredba pridruživanja ima oblik

lvalue = rvalue

b = b + 1
b

c = b = 2*a
b; c

26
26

26
26

a + b = c

Traceback (click to the left of this block for traceback)
...
SyntaxError: can't assign to operator

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "_sage_input_8.py", line 10, in <module>
    exec compile(u'open("___code___.py","w").write("# -*- coding: utf-8 -*-\\n" + _support_.preparse_worksheet_cell(base64.b64decode("YSArIGIgPSBj"),globals())+"\\n"); execfile(os.path.abspath("___code___.py"))
  File "", line 1, in <module>
    
  File "/tmp/tmpxem9Tx/___code___.py", line 2
    a + b = c
SyntaxError: can't assign to operator

c = a + b
c

print a, b
a, b = b, a
print a, b

13 26
26 13

13 26
26 13

l = [1, 2, 3, 4]
print l
l[1] = l[2]
l

[1, 2, 3, 4]
[1, 3, 3, 4]

[1, 2, 3, 4]
[1, 3, 3, 4]

l2 = srange (10)
print l2
l2[2:6] = srange (10, 14)
l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 10, 11, 12, 13, 6, 7, 8, 9]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 10, 11, 12, 13, 6, 7, 8, 9]

l = [1, 2, 3, 4]
[a, b, c, d] = l
print a, b, c, d

1 2 3 4

1 2 3 4

a, b, c, d = l
print a, b, c, d

1 2 3 4

1 2 3 4

Kombinirano pridruživanje je spoj binarne aritmetičke operacije u kojoj se pojavljuje varijabla kojoj će rezultat biti pridružen i pridruživanja:

b = 0
b = b + 1
b

b = 0
b += 1
b

b -= 1
b

a = 3
b += a + 1
print b
b *= 3
b

4
12

4
12

b /= 4
b

b ^= 4
b

b ^= 1/4
b

b = 81
b = b^1/4
print b

81/4

81/4

b = 81
b = b^(1/4)
b

Tipovi

Tipom izraza određeni su

skup vrijednosti koje izraz može poprimiti i
skup funkcija i operatora primjenjivih na njega.

[Podsjećamo vas da smo pojam izraza definirali na drugom predavanju (MPZI_predavanje_02), a da smo aritmetičke i relacijske operacije uveli na prvom predavanju (MPZI_predavanje_01).]

a = 4
b = 2
a + b

# SageMath:
parent (a);  parent (b);  parent (a+b)

Integer Ring
Integer Ring
Integer Ring

Integer Ring
Integer Ring
Integer Ring

# python:
type (a);  type (b);  type (a+b)

<type 'sage.rings.integer.Integer'>
<type 'sage.rings.integer.Integer'>
<type 'sage.rings.integer.Integer'>

<type 'sage.rings.integer.Integer'>
<type 'sage.rings.integer.Integer'>
<type 'sage.rings.integer.Integer'>

b - a;  parent (b-a)

-2
Integer Ring

-2
Integer Ring

a*b;  parent (a*b)

8
Integer Ring

8
Integer Ring

a/b;  parent (a/b)

2
Rational Field

2
Rational Field

c = 3/2
c;  parent (c)

3/2
Rational Field

3/2
Rational Field

d = 1/2
c + d;  parent (c+d)

2
Rational Field

2
Rational Field

f = 3.
g = 2.
f + g;  g + f

5.00000000000000
5.00000000000000

5.00000000000000
5.00000000000000

parent (f);  parent (g);  parent (f+g);  parent (g+f)

Real Field with 53 bits of precision
Real Field with 53 bits of precision
Real Field with 53 bits of precision
Real Field with 53 bits of precision

Real Field with 53 bits of precision
Real Field with 53 bits of precision
Real Field with 53 bits of precision
Real Field with 53 bits of precision

type (f);  type (g);  type (f+g);  type (g+f)

<type 'sage.rings.real_mpfr.RealLiteral'>
<type 'sage.rings.real_mpfr.RealLiteral'>
<type 'sage.rings.real_mpfr.RealNumber'>
<type 'sage.rings.real_mpfr.RealNumber'>

<type 'sage.rings.real_mpfr.RealLiteral'>
<type 'sage.rings.real_mpfr.RealLiteral'>
<type 'sage.rings.real_mpfr.RealNumber'>
<type 'sage.rings.real_mpfr.RealNumber'>

g/f; parent (g/f)

0.666666666666667
Real Field with 53 bits of precision

0.666666666666667
Real Field with 53 bits of precision

h = 'A'
k = 'BC'
h + k; k + h

'ABC'
'BCA'

'ABC'
'BCA'

parent (h);  parent (k);  parent (h+k);  parent (k+h)

<type 'str'>
<type 'str'>
<type 'str'>
<type 'str'>

<type 'str'>
<type 'str'>
<type 'str'>
<type 'str'>

type (h);  type (k);  type (h+k);  type (k+h)

<type 'str'>
<type 'str'>
<type 'str'>
<type 'str'>

<type 'str'>
<type 'str'>
<type 'str'>
<type 'str'>

k - h

Traceback (click to the left of this block for traceback)
...
TypeError: unsupported operand type(s) for -: 'str' and 'str'

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "_sage_input_39.py", line 10, in <module>
    exec compile(u'open("___code___.py","w").write("# -*- coding: utf-8 -*-\\n" + _support_.preparse_worksheet_cell(base64.b64decode("ayAtIGg="),globals())+"\\n"); execfile(os.path.abspath("___code___.py"))
  File "", line 1, in <module>
    
  File "/tmp/tmppwenqc/___code___.py", line 2, in <module>
    exec compile(u'k - h
  File "", line 1, in <module>
    
TypeError: unsupported operand type(s) for -: 'str' and 'str'

h*k

Traceback (click to the left of this block for traceback)
...
TypeError: can't multiply sequence by non-int of type 'str'

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "_sage_input_40.py", line 10, in <module>
    exec compile(u'open("___code___.py","w").write("# -*- coding: utf-8 -*-\\n" + _support_.preparse_worksheet_cell(base64.b64decode("aCpr"),globals())+"\\n"); execfile(os.path.abspath("___code___.py"))
  File "", line 1, in <module>
    
  File "/tmp/tmpD6fnYz/___code___.py", line 2, in <module>
    exec compile(u'h*k
  File "", line 1, in <module>
    
TypeError: can't multiply sequence by non-int of type 'str'

4*k; k*4; parent (4*k)

'BCBCBCBC'
'BCBCBCBC'
<type 'str'>

'BCBCBCBC'
'BCBCBCBC'
<type 'str'>

l = [1, 2, 3, 4]
ll = [5, 6]
l + ll;  ll + l

[1, 2, 3, 4, 5, 6]
[5, 6, 1, 2, 3, 4]

[1, 2, 3, 4, 5, 6]
[5, 6, 1, 2, 3, 4]

parent (l);  parent (ll);  parent (l+ll);  parent (ll+l)

<type 'list'>
<type 'list'>
<type 'list'>
<type 'list'>

<type 'list'>
<type 'list'>
<type 'list'>
<type 'list'>

2*l; l*2; parent (2*l)

[1, 2, 3, 4, 1, 2, 3, 4]
[1, 2, 3, 4, 1, 2, 3, 4]
<type 'list'>

[1, 2, 3, 4, 1, 2, 3, 4]
[1, 2, 3, 4, 1, 2, 3, 4]
<type 'list'>

U prethodnim izrazima tipovi su određeni implicitno na temelju konstanata i operacija koje se u njima pojavljuju. No, tipovi se mogu, a u nekim slučajevima i moraju, eksplicitno zadati:

... cijeli brojevi:

c = 2
c;  parent (c)

2
Integer Ring

2
Integer Ring

c = Integer (2)
c;  parent (c)

2
Integer Ring

2
Integer Ring

c = ZZ (2)
c;  parent (c)

2
Integer Ring

2
Integer Ring

c = int (2)
c; parent (c)

2
<type 'int'>

2
<type 'int'>

... racionalni brojevi:

c = 1/2
c;  parent (c)

1/2
Rational Field

1/2
Rational Field

c = 2/1
c;  parent (c)

2
Rational Field

2
Rational Field

c = Rational (2)
c;  parent (c)

2
Rational Field

2
Rational Field

c = QQ (3)
c;  parent (c)

3
Rational Field

3
Rational Field

... „realni” brojevi:

c = RealNumber (4)
c;  parent (c)

4.00000000000000
Real Field with 53 bits of precision

4.00000000000000
Real Field with 53 bits of precision

c = RR (4)
c;  parent (c)

4.00000000000000
Real Field with 53 bits of precision

4.00000000000000
Real Field with 53 bits of precision

c = float (4)
c;  parent (c)

4.0
<type 'float'>

4.0
<type 'float'>

RF80 = RealField (80)
RF12 = RealField (12)

d = RF80 (5)
f = RF12 (0.6)
d;  f

5.0000000000000000000000
0.600

5.0000000000000000000000
0.600

parent (d);  parent (f)

Real Field with 80 bits of precision
Real Field with 12 bits of precision

Real Field with 80 bits of precision
Real Field with 12 bits of precision

parent (N (5, digits = 23))

Real Field with 80 bits of precision

Real Field with 80 bits of precision

prikaz s pomičnim (plivajućim) zarezom (u engleskom: s plivajućom točkom — floating point):

dekadski sustav: $x = \pm m \cdot 10^e$

$m$ — mantisa, $1 \le m < 10$ ili $m = 0$

$e$ — eksponent

$123\,456\,780\,000\,000\,000\,000,\!0 \,=\,1,\!234\,567\,8 \cdot 10^{20}$

$123,\!456\,78 \,=\, 1,\!234\,567\,8 \cdot 10^2$

$0,\!000\,123\,456\,78 = 1,\!234\,567\,8 \cdot 10^{-4}$

$0,\!000\,000\,000\,000\,000\,000\,012\,345\,678 \,=\, 1,\!234\,567\,8 \cdot 10^{-20}$

binarni sustav (najjednostavnije): $x = s \cdot m \cdot 2^e$

$s \in \{ -1,\, 1 \}$

$m$ — mantisa, $1 \le m < 2$ ili $m = 0$

$e$ — eksponent

točnost (precision) prikaza s pomičnim zarezom ovisi o broju bitova mantise (binarnih značajnih znamenaka)
- ako je u binarnom sustavu mantisa broja zapisana sa $p$ bitova, onda će u dekadskom sustavu broj imati $p\cdot \log_{10}2$ značajnih znamenaka
- za zapis $d$ dekadskih značajnih znamenaka potrebno je $d\cdot \log_{2}10$ bitova

značajnim znamenkama broja $x\ne 0$ u zapisu sa zarezom nazivaju se prva znamenka slijeva različita od nule i sve znamenke desno od nje do kraja zapisa; za $x = 0$ sve su znamenke u zapisu značajne

53 * log (2., 10);  80 * log (2., 10);  12 * log (2., 10)

15.9545897701910
24.0823996531185
3.61235994796777

15.9545897701910
24.0823996531185
3.61235994796777

round (53 * log (2, 10));  round (80 * log (2, 10));  round (12 * log (2, 10))

16
24
4

16
24
4

... imaginarni i kompleksni brojevi:

cc = I
cc;  parent (cc)

I
Symbolic Ring

I
Symbolic Ring

cc = i
cc; parent (cc)

I
Symbolic Ring

I
Symbolic Ring

cc = CC (I)
cc;  parent (cc)

1.00000000000000*I
Complex Field with 53 bits of precision

1.00000000000000*I
Complex Field with 53 bits of precision

cc = CC (0, 1)
cc;  parent (cc)

1.00000000000000*I
Complex Field with 53 bits of precision

1.00000000000000*I
Complex Field with 53 bits of precision

cc = CC (1)
cc; parent (cc)

1.00000000000000
Complex Field with 53 bits of precision

1.00000000000000
Complex Field with 53 bits of precision

cc = 4 + 3*i
cc;  parent (cc)

3*I + 4
Symbolic Ring

3*I + 4
Symbolic Ring

cc = 4. + 3.*i
cc;  parent (cc)

4.00000000000000 + 3.00000000000000*I
Symbolic Ring

4.00000000000000 + 3.00000000000000*I
Symbolic Ring

cc = CC (4 + 3*i)
cc;  parent (cc)

4.00000000000000 + 3.00000000000000*I
Complex Field with 53 bits of precision

4.00000000000000 + 3.00000000000000*I
Complex Field with 53 bits of precision

cc = CC (4, 3)
cc;  parent (cc)

4.00000000000000 + 3.00000000000000*I
Complex Field with 53 bits of precision

4.00000000000000 + 3.00000000000000*I
Complex Field with 53 bits of precision

cc = ComplexNumber (0, 1)
cc;  parent (cc)

1.00000000000000*I
Complex Field with 53 bits of precision

1.00000000000000*I
Complex Field with 53 bits of precision

cc = ComplexNumber (3, 4)
cc;  parent (cc)

3.00000000000000 + 4.00000000000000*I
Complex Field with 53 bits of precision

3.00000000000000 + 4.00000000000000*I
Complex Field with 53 bits of precision

cc = ComplexField(80) (3, 4)
cc;  parent (cc)

3.0000000000000000000000 + 4.0000000000000000000000*I
Complex Field with 80 bits of precision

3.0000000000000000000000 + 4.0000000000000000000000*I
Complex Field with 80 bits of precision

... vektori:

u = vector (QQ, [1, 2, 3])
v = vector (QQ, [4, 5, 6])
u + v

(5, 7, 9)

(5, 7, 9)

parent (u);  parent (v);  parent (u+v)

Vector space of dimension 3 over Rational Field
Vector space of dimension 3 over Rational Field
Vector space of dimension 3 over Rational Field

Vector space of dimension 3 over Rational Field
Vector space of dimension 3 over Rational Field
Vector space of dimension 3 over Rational Field

u*v;  parent (u*v)

32
Rational Field

32
Rational Field

u.cross_product (v);  parent (u.cross_product (v))

(-3, 6, -3)
Vector space of dimension 3 over Rational Field

(-3, 6, -3)
Vector space of dimension 3 over Rational Field

u.tensor_product (v);  parent (u.tensor_product (v))

[ 4  5  6]
[ 8 10 12]
[12 15 18]
Full MatrixSpace of 3 by 3 dense matrices over Rational Field

[ 4  5  6]
[ 8 10 12]
[12 15 18]
Full MatrixSpace of 3 by 3 dense matrices over Rational Field

Pretvorba tipova u „miješanim” aritmetičkim operacijama:

... $\to$ $\to$ $\to$ CC

a = 3
c = 3/2
parent (a); parent (c)

Integer Ring
Rational Field

Integer Ring
Rational Field

a + c;  parent (a+c)

9/2
Rational Field

9/2
Rational Field

f = 3.
parent (f)

Real Field with 53 bits of precision

Real Field with 53 bits of precision

a + f;  parent (a+f)

6.00000000000000
Real Field with 53 bits of precision

6.00000000000000
Real Field with 53 bits of precision

c + f;  parent (c+f)

4.50000000000000
Real Field with 53 bits of precision

4.50000000000000
Real Field with 53 bits of precision

cc = CC (4., 3.)
parent (cc)

Complex Field with 53 bits of precision

Complex Field with 53 bits of precision

cc + f;  parent (cc+f)

7.00000000000000 + 3.00000000000000*I
Complex Field with 53 bits of precision

7.00000000000000 + 3.00000000000000*I
Complex Field with 53 bits of precision

... $\to$ ako je $>$ n

r = RF12 (3)
r;  parent (r)

3.00
Real Field with 12 bits of precision

3.00
Real Field with 12 bits of precision

f + r;  parent (f + r);  r + f;  parent (r+f)

6.00
Real Field with 12 bits of precision
6.00
Real Field with 12 bits of precision

6.00
Real Field with 12 bits of precision
6.00
Real Field with 12 bits of precision

O pridruživanju, još i opet...

a = 1
b = a
a;  b

1
1

1
1

a = 3
a;  b

3
1

3
1

... ali, za složen(ij)e tipove:

u = vector ([1, 2, 3])
v = u
v[1] = 20
v;  u

(1, 20, 3)
(1, 20, 3)

(1, 20, 3)
(1, 20, 3)

u = vector ([1, 2, 3])
v = copy (u)
v[1] = 20
v;  u

(1, 20, 3)
(1, 2, 3)

(1, 20, 3)
(1, 2, 3)

MPZI_predavanje_10

2421 days ago by fresl