Contact
CoCalc Logo Icon
StoreFeaturesDocsShareSupport News AboutSign UpSign In
| Download
Views: 578
Kernel: Anaconda (Python 3)

Numpy

numpy je paket (modul) za (efikasno) numeričko računanje u Pythonu. Naglasak je na efikasnom računanju s nizovima, vektorima i matricama, uključivo višedimenzionalne stukture. Napisan je u C-u i Fortanu te koristi BLAS biblioteku.

from numpy import *

Kreiranje nizova pomoću numpy modula

v = array([1,2,3,4])
v
array([1, 2, 3, 4])
M = array([[1, 2], [3, 4]])
M
array([[1, 2], [3, 4]])
type(v), type(M)
(numpy.ndarray, numpy.ndarray)
v.shape
(4,)
M.shape
(2, 2)
v.size, M.size
(4, 4)

Možemo koristiti i funkcije numpy.shape, numpy.size

shape(M)
(2, 2)
size(M)
4

Koja je razlika između numpy.ndarray tipa i standardnih lista u Pythonu?

  • liste u Pythonu mogu sadržavati bilo kakve vrste objekata, to nije slučaj s numpy.ndarray

  • numpy.ndarray nisu dinamički objekti: pri kreiranju im je određen tip

  • za numpy.ndarray implementirane su razne efikasne metode važne u numerici

  • de facto sva računanja se odvijaju u C-u i Fortranu pomoću BLAS rutina

dtype (data type) nam daje informaciju o tipu podataka u nizu:

M.dtype
dtype('int64')

Kako je M statički objekt, ne možemo napraviti ovo:

M[0,0] = "hello"
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-31-a09d72434238> in <module>() ----> 1 M[0,0] = "hello" ValueError: invalid literal for int() with base 10: 'hello'

Naravno, ovo je ok:

M[0,0]=5

dtype se može eksplicitno zadati:

M = array([[1, 2], [3, 4]], dtype=complex)
M
array([[ 1.+0.j, 2.+0.j], [ 3.+0.j, 4.+0.j]])

Tipično dtype su: int, float, complex, bool, object, itd.

Ali možemo biti i eksplicitni vezano za veličinu registra: int64, int16, float128, complex128.

Funkcije koje generiraju nizove

x = arange(0, 10, 1) # argumenti: početak, kraj, korak

x # 10 nije u nizu!
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x = arange(-1, 1, 0.1)
x
array([ -1.00000000e+00, -9.00000000e-01, -8.00000000e-01, -7.00000000e-01, -6.00000000e-01, -5.00000000e-01, -4.00000000e-01, -3.00000000e-01, -2.00000000e-01, -1.00000000e-01, -2.22044605e-16, 1.00000000e-01, 2.00000000e-01, 3.00000000e-01, 4.00000000e-01, 5.00000000e-01, 6.00000000e-01, 7.00000000e-01, 8.00000000e-01, 9.00000000e-01])
# ovdje su i početak i kraj uključeni!
linspace(0, 10, 25)
array([ 0. , 0.41666667, 0.83333333, 1.25 , 1.66666667, 2.08333333, 2.5 , 2.91666667, 3.33333333, 3.75 , 4.16666667, 4.58333333, 5. , 5.41666667, 5.83333333, 6.25 , 6.66666667, 7.08333333, 7.5 , 7.91666667, 8.33333333, 8.75 , 9.16666667, 9.58333333, 10. ])
logspace(0, 10, 10, base=e)
array([ 1.00000000e+00, 3.03773178e+00, 9.22781435e+00, 2.80316249e+01, 8.51525577e+01, 2.58670631e+02, 7.85771994e+02, 2.38696456e+03, 7.25095809e+03, 2.20264658e+04])
x, y = mgrid[0:5, 0:5] # slično kao meshgrid u MATLAB-u

x
array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]])
y
array([[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]])
from numpy import random

# uniformna distribucija na [0,1]
random.rand(5,5)
array([[ 0.46634159, 0.18383259, 0.99043082, 0.95553566, 0.86117026], [ 0.18758889, 0.66275122, 0.88660117, 0.48603761, 0.58020297], [ 0.76289553, 0.66796829, 0.70291958, 0.84876206, 0.90293859], [ 0.62222178, 0.46259364, 0.86471336, 0.73420665, 0.21731253], [ 0.63499971, 0.49470533, 0.06818067, 0.85432396, 0.87013258]])
# standardna normalna distribucija
random.randn(5,5)
array([[ 1.8841264 , 1.79222299, -0.15896515, -0.95471483, 0.604597 ], [ 0.01879898, -0.21818353, -0.02871515, -0.17077362, 2.32474892], [ 0.47474772, 0.30405552, -0.37323118, -0.60411745, 1.06795274], [-0.2546505 , -0.10511935, 0.73920025, 2.50885605, -1.04196785], [ 0.2522967 , -0.87931277, -0.93793984, -0.71194124, 0.67464873]])
# dijagonalna matrica
diag([1,2,3])
array([[1, 0, 0], [0, 2, 0], [0, 0, 3]])
# matrica sa sporednom dijagonalom
diag([1,2,3], k=1)
array([[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3], [0, 0, 0, 0]])
zeros((3,3))
array([[ 0., 0., 0.], [ 0., 0., 0.], [ 0., 0., 0.]])
ones((3,3))
array([[ 1., 1., 1.], [ 1., 1., 1.], [ 1., 1., 1.]])

Učitavanje podataka

Često učitavamo podatke iz datoteka (lokalno ili s weba). Važni formati su cvs (comma-separated values) i tsv (tab-separated values).

!head tpt-europe.csv
1850,-0.211 1851,-0.403 1852,0.334 1853,-0.762 1854,-0.019 1855,-0.961 1856,-0.243 1857,0.420 1858,-0.059 1859,0.018 
data = genfromtxt('tpt-europe.csv')

data.shape, data.dtype
((158,), dtype('float64'))

Uz numpy.savetxt možemo napraviti i obrnuto.

M = random.rand(3,3)
M
array([[ 0.93875912, 0.43215004, 0.23129988], [ 0.13593153, 0.0413665 , 0.21458492], [ 0.96261572, 0.22372779, 0.44478241]])
savetxt("random-matrix.csv", M)

!cat random-matrix.csv
9.387591161588458855e-01 4.321500444939530006e-01 2.312998801967627305e-01 1.359315283144698627e-01 4.136650288835774791e-02 2.145849165333063580e-01 9.626157155774026641e-01 2.237277861211310892e-01 4.447824126746069417e-01 
savetxt("random-matrix.csv", M, fmt='%.5f') # s fmt specificiramo format

!cat random-matrix.csv
0.93876 0.43215 0.23130 0.13593 0.04137 0.21458 0.96262 0.22373 0.44478

Postoji i interni format za numpy nizove:

save("random-matrix.npy", M)

!file random-matrix.npy
random-matrix.npy: data 
load("random-matrix.npy")
array([[ 0.93875912, 0.43215004, 0.23129988], [ 0.13593153, 0.0413665 , 0.21458492], [ 0.96261572, 0.22372779, 0.44478241]])
M.itemsize # byte-ovi po elementu
8
M.nbytes
72
M.ndim
2

Rad s nizovima

Indeksiranje funkcionira standardno.

v[0]
1
 M[1,1]
0.041366502888357748
M
array([[ 0.93875912, 0.43215004, 0.23129988], [ 0.13593153, 0.0413665 , 0.21458492], [ 0.96261572, 0.22372779, 0.44478241]])
M[1]
array([ 0.13593153, 0.0413665 , 0.21458492])

Naravno, možemo koristiti i : operator: 

M[1,:] # redak 1
array([ 0.13593153, 0.0413665 , 0.21458492])
M[:,1] # stupac 1
array([ 0.43215004, 0.0413665 , 0.22372779])
M[1,:] = 0
M[:,2] = -1

M
array([[ 0.93875912, 0.43215004, -1. ], [ 0. , 0. , -1. ], [ 0.96261572, 0.22372779, -1. ]])
A = array([1,2,3,4,5])
A
array([1, 2, 3, 4, 5])
A[1:3]
array([2, 3])
A[1:3] = [-2,-3]
A
array([ 1, -2, -3, 4, 5])
A[::]
array([ 1, -2, -3, 4, 5])
A[::2]
array([ 1, -3, 5])
A[:3]
array([ 1, -2, -3])
A[3:]
array([4, 5])

S negativnim indeksima računamo od kraja niza:

A = array([1,2,3,4,5])

A[-1] # zadnji element niza
5
A[-3:] # zadnja tri elementa
array([3, 4, 5])

Naravno, iste operacije imamo i za višedimenzionalne nizove.

A = array([[n+m*10 for n in range(5)] for m in range(5)])
A
array([[ 0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]])
A[1:4, 1:4]
array([[11, 12, 13], [21, 22, 23], [31, 32, 33]])
A[::2, ::2]
array([[ 0, 2, 4], [20, 22, 24], [40, 42, 44]])
indeksi_redaka = [1, 2, 3]
A[indeksi_redaka]
array([[10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34]])
indeksi_stupaca = [1, 2, -1]
A[indeksi_redaka, indeksi_stupaca]
array([11, 22, 34])

Možemo koristiti i tzv. maske: ako je maska numpy niz tipa bool, tada se izabiru oni elementi koji u maski odgovaraju vrijednosti True.

B = array([n for n in range(5)])
B
array([0, 1, 2, 3, 4])
maska = array([True, False, True, False, False])
B[maska]
array([0, 2])
maska = array([1,0,1,0,0], dtype=bool)
B[maska]
array([0, 2])

Zanimljiviji primjer:

x = arange(0, 10, 0.5)
x
array([ 0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])
maska = (5 < x) * (x < 7.5)
maska
array([False, False, False, False, False, False, False, False, False, False, False, True, True, True, True, False, False, False, False, False], dtype=bool)
x[maska]
array([ 5.5, 6. , 6.5, 7. ])

Funkcije na nizovima

indeksi = where(maska)
indeksi
(array([11, 12, 13, 14]),)
x[indeksi]
array([ 5.5, 6. , 6.5, 7. ])
print(A)
diag(A)
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34] [40 41 42 43 44]]
array([ 0, 11, 22, 33, 44])
diag(A, -1)
array([10, 21, 32, 43])
v2 = arange(-3,3)
v2
array([-3, -2, -1, 0, 1, 2])
indeksi_redaka = [1, 3, 5]
v2[indeksi_redaka]
array([-2, 0, 2])
v2.take(indeksi_redaka)
array([-2, 0, 2])

U sljedećem primjeru take djeluje na listu, a izlaz je array: 

take([-3, -2, -1,  0,  1,  2], indeksi_redaka)
array([-2, 0, 2])

Funkcija choose:

koji = [1, 0, 1, 0]
izbori = [[-1,-2,-3,-4], [5,4,3,2]]

choose(koji, izbori)
array([ 5, -2, 3, -4])

Što radi ova funkcija?

Vektorizacija koda

Što je više operacija s nizovima, to će kod generalno biti brži.

v1 = arange(0, 5)

v1 * 2
array([0, 2, 4, 6, 8])
v1 + 2
array([2, 3, 4, 5, 6])
print(A)
A * 2, A + 2
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34] [40 41 42 43 44]]
(array([[ 0, 2, 4, 6, 8], [20, 22, 24, 26, 28], [40, 42, 44, 46, 48], [60, 62, 64, 66, 68], [80, 82, 84, 86, 88]]), array([[ 2, 3, 4, 5, 6], [12, 13, 14, 15, 16], [22, 23, 24, 25, 26], [32, 33, 34, 35, 36], [42, 43, 44, 45, 46]]))

Defaultne operacije na nizovima su uvijek definirane po elementima.

A * A
array([[ 0, 1, 4, 9, 16], [ 100, 121, 144, 169, 196], [ 400, 441, 484, 529, 576], [ 900, 961, 1024, 1089, 1156], [1600, 1681, 1764, 1849, 1936]])
v1 * v1
array([ 0, 1, 4, 9, 16])
A.shape, v1.shape
((5, 5), (5,))
print(A,v1)
A * v1
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34] [40 41 42 43 44]] [0 1 2 3 4]
array([[ 0, 1, 4, 9, 16], [ 0, 11, 24, 39, 56], [ 0, 21, 44, 69, 96], [ 0, 31, 64, 99, 136], [ 0, 41, 84, 129, 176]])

Kako doći do standardnog umnoška?

dot(A, A)
array([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]])
A @ A # nova operacija definirana u Python-u 3.5+
array([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]])
matmul(A,A) # @ je zapravo pokrata za matmul, dot i matmul nisu iste operacije (poklapaju se na 1D i 2D nizovima)
array([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]])
dot(A, v1)
array([ 30, 130, 230, 330, 430])
A @ v1
array([ 30, 130, 230, 330, 430])
v1 @ v1 # analogno dot(v1, v1)
30

Matrice mogu biti i višedimenzionalne

a = random.rand(8,13,13)
b = random.rand(8,13,13)
matmul(a, b).shape
(8, 13, 13)

Postoji i tip matrix. Kod njega operacije +, -, * se ponašaju onako kako smo navikli.

M = matrix(A)
v = matrix(v1).T # da bi dobili stupčasti vektor

v
matrix([[0], [1], [2], [3], [4]])
M*M
matrix([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]])
M*v
matrix([[ 30], [130], [230], [330], [430]])
# skalarni produkt
v.T * v
matrix([[30]])
v + M*v
matrix([[ 30], [131], [232], [333], [434]])

Naravno, dimenzije trebaju biti kompatibilne.

v = matrix([1,2,3,4,5,6]).T

shape(M), shape(v)
((5, 5), (6, 1))
M * v
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-138-995fb48ad0cc> in <module>() ----> 1 M * v /projects/anaconda3/lib/python3.5/site-packages/numpy/matrixlib/defmatrix.py in __mul__(self, other) 341 if isinstance(other, (N.ndarray, list, tuple)) : 342 # This promotes 1-D vectors to row vectors --> 343 return N.dot(self, asmatrix(other)) 344 if isscalar(other) or not hasattr(other, '__rmul__') : 345 return N.dot(self, other) ValueError: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)

Još neke funkcije: inner, outer, cross, kron, tensordot.

C = matrix([[1j, 2j], [3j, 4j]])
C
matrix([[ 0.+1.j, 0.+2.j], [ 0.+3.j, 0.+4.j]])
conjugate(C)
matrix([[ 0.-1.j, 0.-2.j], [ 0.-3.j, 0.-4.j]])

Adjungiranje:

C.H
matrix([[ 0.-1.j, 0.-3.j], [ 0.-2.j, 0.-4.j]])

Za izvlačenje realnog, odnosno imaginarnog dijela: real i imag:

real(C) # isto što i C.real
matrix([[ 0., 0.], [ 0., 0.]])
imag(C) # isto što i C.imag
matrix([[ 1., 2.], [ 3., 4.]])
angle(C+1) # u MATLAB-u je to funkcija arg, dakle argument (faza) kompleksnog broja
array([[ 0.78539816, 1.10714872], [ 1.24904577, 1.32581766]])
abs(C)
matrix([[ 1., 2.], [ 3., 4.]])
from numpy.linalg import inv, det
inv(C) # isto što i C.I
matrix([[ 0.+2.j , 0.-1.j ], [ 0.-1.5j, 0.+0.5j]])
C.I * C
matrix([[ 1.00000000e+00+0.j, 0.00000000e+00+0.j], [ 1.11022302e-16+0.j, 1.00000000e+00+0.j]])
det(C)
(2.0000000000000004+0j)
det(C.I)
(0.49999999999999967+0j)

Izvlačenje osnovih informacija iz nizova

# u stockholm_td_adj.dat su podaci o vremenu za Stockholm
dataStockholm = genfromtxt('stockholm_td_adj.dat')
dataStockholm.shape
(77431, 7)
# temperatura se nalazi u 4. stupcu (znači stupcu broj 3)
mean(dataStockholm[:,3])
6.1971096847515854

Prosječna dnevna temperatura u Stockholmu u zadnjiih 200 godina je bila 6.2 C.

std(dataStockholm[:,3]), var(dataStockholm[:,3])
(8.2822716213405734, 68.596023209663414)
dataStockholm[:,3].min()
-25.800000000000001
dataStockholm[:,3].max()
28.300000000000001
d = arange(0, 10)
d
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
sum(d)
45
prod(d+1)
3628800
# kumulativa suma
cumsum(d)
array([ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45])
# kumulativan produkt
cumprod(d+1)
array([ 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800])
# isto što i: diag(A).sum()
trace(A)
110

Naravno, sve ove operacije možemo raditi na dijelovima nizova.

!head -n 3 stockholm_td_adj.dat
1800 1 1 -6.1 -6.1 -6.1 1 1800 1 2 -15.4 -15.4 -15.4 1 1800 1 3 -15.0 -15.0 -15.0 1

Format je: godina, mjesec, dan, prosječna dnevna temperatura, najniža, najviša, lokacija.

Recimo da nas zanimaju samo temperature u veljači.

# mjeseci su 1.,..., 12.
unique(dataStockholm[:,1])
array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.])
maska_velj = dataStockholm[:,1] == 2

mean(dataStockholm[maska_velj,3])
-3.2121095707365961

Sada nije problem doći do histograma za prosječne mjesečne temperature u par redaka.

mjeseci = arange(1,13)
mjeseci_prosjek = [mean(dataStockholm[dataStockholm[:,1] == mjesec, 3]) for mjesec in mjeseci]

from pylab import *
%matplotlib inline
fig, ax = subplots()
ax.bar(mjeseci, mjeseci_prosjek)
ax.set_xlabel("Mjesec")
ax.set_ylabel("Prosj. mj. temp.");
Image in a Jupyter notebook

Rad s višedimenzionalnim podacima

m = rand(3,3)
m
array([[ 0.66942337, 0.98488678, 0.06962048], [ 0.93170674, 0.70455373, 0.10112863], [ 0.4101218 , 0.20957115, 0.9954116 ]])
m.max()
0.99541159521774658
# max u svakom stupcu
m.max(axis=0)
array([ 0.93170674, 0.98488678, 0.9954116 ])
# max u svakom retku
m.max(axis=1)
array([ 0.98488678, 0.93170674, 0.9954116 ])

Oblik niza se može promijeniti bez da se dira memorija, dakle mogu se primijenjivati i na veliku količinu podataka.

A
array([[ 0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]])
n, m = A.shape

B = A.reshape((1,n*m))
B
array([[ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44]])
B[0,0:5] = 5 # promijenili smo B
B
array([[ 5, 5, 5, 5, 5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44]])
A # a time smo promijenili i A
array([[ 5, 5, 5, 5, 5], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]])

Funkcija flatten radi kopiju.

B = A.flatten()
B
array([ 5, 5, 5, 5, 5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44])
B[0:5] = 10
B
array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44])
A # A je sad ostao isti
array([[ 5, 5, 5, 5, 5], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]])
v = array([1,2,3])

shape(v)
(3,)
# pretvorimo v u matricu
v[:, newaxis]
array([[1], [2], [3]])
v[:,newaxis].shape
(3, 1)
v[newaxis,:].shape
(1, 3)
a = array([[1, 2], [3, 4]])

# ponovimo svaki element tri puta
repeat(a, 3)
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])
tile(a, 3)
array([[1, 2, 1, 2, 1, 2], [3, 4, 3, 4, 3, 4]])
b = array([[5, 6]])

concatenate((a, b), axis=0)
array([[1, 2], [3, 4], [5, 6]])
concatenate((a, b.T), axis=1)
array([[1, 2, 5], [3, 4, 6]])
vstack((a,b))
array([[1, 2], [3, 4], [5, 6]])
hstack((a,b.T))
array([[1, 2, 5], [3, 4, 6]])

Kopiranje nizova

A = array([[1, 2], [3, 4]])
A
array([[1, 2], [3, 4]])
# B je isto što i A (bez kopiranja podataka)
B = A

Ako želimo napraviti novu kopiju, koristimo funkciju copy:

B = copy(A)

v = array([1,2,3,4])

for element in v:
    print (element)
1 2 3 4 
M = array([[1,2], [3,4]])

for row in M:
    print ("redak {}".format(row))
    
    for element in row:
        print (element)
redak [1 2] 1 2 redak [3 4] 3 4

Funkcija enumerate nam daje i element i njegov indeks:

for row_idx, row in enumerate(M):
    print ("indeks retka {} redak {}".format(row_idx, row))
    
    for col_idx, element in enumerate(row):
        print ("col_idx {} element {}".format(col_idx, element))
        M[row_idx, col_idx] = element ** 2
indeks retka 0 redak [1 2] col_idx 0 element 1 col_idx 1 element 2 indeks retka 1 redak [3 4] col_idx 0 element 3 col_idx 1 element 4

Vektorizacija funkcija

def Theta(x):
    """
    Sklarna verzija step funkcije.
    """
    if x >= 0:
        return 1
    else:
        return 0

Theta(array([-3,-2,-1,0,1,2,3]))
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-198-6658efdd2f22> in <module>() ----> 1 Theta(array([-3,-2,-1,0,1,2,3])) <ipython-input-197-840f7d4ff406> in Theta(x) 3 Sklarna verzija step funkcije. 4 """ ----> 5 if x >= 0: 6 return 1 7 else: ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() 
Theta_vec = vectorize(Theta)

Theta_vec(array([-3,-2,-1,0,1,2,3]))
array([0, 0, 0, 1, 1, 1, 1])

To smo mogli napraviti i ručno.

def Theta(x):
    """
    Vektorska verzija step funkcije.
    """
    return 1 * (x >= 0)

Theta(array([-3,-2,-1,0,1,2,3]))
array([0, 0, 0, 1, 1, 1, 1])
# radi naravno i za skalare
Theta(-1.2), Theta(2.6)
(0, 1)
M
array([[ 1, 4], [ 9, 16]])
if (M > 5).any():
    print ("barem jedan element iz M je veći od 5")
else:
    print ("svi elementi iz M su manji ili jednaki od 5")
barem jedan element iz M je veći od 5 
if (M > 5).all():
    print ("svi elementi iz M su veći od 5")
else:
    print ("barem jedan element je manji ili jednak od 5")
barem jedan element je manji ili jednak od 5

Eksplicitno pretvaranje podataka. Uvijek stvara novi niz.

M.dtype
dtype('int64')
M2 = M.astype(float)
M2
array([[ 1., 4.], [ 9., 16.]])
M2.dtype
dtype('float64')
M3 = M.astype(bool)
M3
array([[ True, True], [ True, True]], dtype=bool)
from verzije import *
from IPython.display import HTML
HTML(print_sysinfo()+info_packages('numpy,matplotlib'))
Python verzija3.5.3
kompajlerGCC 4.8.2 20140120 (Red Hat 4.8.2-15)
sustavLinux
broj CPU-a8
interpreter64bit
numpy verzija1.11.3
matplotlib verzija2.0.0

Zadaci za vježbu

  • Matrica AA reda 5 je dobijena s A=random.randn(5,5). Izvucite 2×22\times 2 matricu BB iz gornjeg desnog kuta matrice AA. Pomnožite matricu BB s nekom drugom 2×22\times 2 matricom te ubacite tu matricu u gornji lijevi kut matrice AA.

  • Dan je kod

x = linspace(0, 1, 3)
# y = 2*x + 1:
y=x; y*=2; y+=1
# z = 4*x - 4:
z=x; z*=4; z-=4 
print (x, y, z)

Izvršite ovaj kod. Objasnite zašto x, y i z imaju iste vrijednosti.

  • Vektorizirajte kod iz 3. zadatka za vježbu iz prvog predavanja. Vektorizirana funkcija treba za argumente primati funkciju f i broj n te dva niza a,b a vraćati niz brojeva koji odgovaraju aproksimaciji integrala ∫aibif(x)dx\int_{a_i}^{b_i} f(x) dx trapeznom formulom.

  • Dana je funkcija f(x)=nn+1{(1/2)1+1/n−(1/2−x)1+1/n,0≤x≤1/2,(1/2)1+1/n−(x−1/2)1+1/n,1/2<x≤1. f(x)=\frac{n}{n+1}\begin{cases} (1/2)^{1+1/n}-(1/2-x)^{1+1/n}, & 0\le x\le 1/2,\\ (1/2)^{1+1/n}-(x-1/2)^{1+1/n}, & 1/2 < x\le 1. \end{cases} Ovdje je nn realan broj, 0<n≤10 < n \le 1. Napišite vektoriziranu funkciju za računanje f(x)f(x) na skupu mm ekvidistribuiranih brojeva između 0 i 1 (dakle, bez korištenja petlji).

  • Neka su x1,…,xnx_1,\ldots,x_n uniformno distribuirani slučajni brojevi između aa i bb. Tada se ∫abf(x)d x\int_a^b f(x)\mathrm{d}\,x može aproksimirati s b−an∑i=1nf(xi)\frac{b-a}{n} \sum_{i=1}^n f(x_i), postupak koji se obično zove Monte Carlo integracija. Napišite funkciju koja kao ulazne varijable prima aa, bb, ff te nn s predefiniranom vrijednošću 1000, a vraća rezultat Monte Carlo integracije. I u ovom zadatku se ne smiju koristiti petlje.