numpy

https://numpy.org/doc/stable/

Il python (classico) dispone di oggetti array.array (monodimensionali)

numpy permette di usare un nuovo tipo di array

 numpy.ndarray 

• ndarray = N-dimensional array, ndarray, sono noti anche con il termine “array”, cosa che potrebbe causare confusione se non si usasse il nome del modulo (numpy) come prefisso (numpy.array)

• dtype = data type

1.py

import numpy as np
a = [[ 1., 0., 0.], [ 0., 1., 2.]]
b = np.array([1.2, 3.5, 5.1])
c = np.array( [ [1.0,2.0], [3.0,4.0] ], dtype=complex ) # oppure int32
d = np.zeros((3, 4))
e = np.ones((3, 4))
del e    # libera la memoria

• shape = definisce la forma (le dimensioni) dell'array, cioè la grandezza (size) di ogni asse
• nel precedente esempio
  • la variabile a, ha due assi, il primo ha lunghezza 3, il secondo ha lunghezza 2
  • la variabile b ha due assi, il primo ha lunghezza 3, il secondo ha lunghezza 1, quindi si dice che ha un solo asse.
• Per comprendere questo termine (numero di assi) basta immaginare che la variabile b possa essere usata per contenere i punti dell'asse x

Questa istruzione preleva solo alcuni valori, tutti e tre della seconda colonna.

c[0:2, 1]
c[:,1]     # equivalente

(Per una matrice 2D, quando si richiama un elemento, è del tipo nome[riga,colonna])

usando un indice si stampano intere righe alla volta

  >>> for riga in c:
  ...     print(row)

usando flat si stampano i singoli elementi

  >>> for elemento in c.flat:
  ...     print(element)

2.py

from numpy import pi
x = np.linspace( 0, 2*pi, 100 )        # useful to evaluate function at lots of points
f = np.sin(x)
b = np.fromfunction(f,(100,0),dtype=int)
y,x = np.ogrid[ -1.4:1.4:h*1j, -2:0.8:w*1j ]

Scopriamo che è semplice fare le operazioni sui singoli elementi (potenze)

  >>> b = np.array([1.2, 3.5, 5.1])
  >>> b**2
  array([ 1.44, 12.25, 26.01])

Di solito si moltiplicano due array 1 D e si ottiene un terzo array 1 D, ortogonale.

  numpy.cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)

Ha un comportamento diverso, a seconda dei fattori utilizzati

• usando il tipo scalare 0 D, equivale a fare il prodotto con asterisco *
• usando il tipo array 1 D, equivale a fare il prodotto scalare, o somma dei prodotti
• usando il tipo array 2 D, ………

   fare un esempio....

Quando gli array sono 2D è preferibile usare @

  >>> d @ e

  b.sum()         # somma tutti gli elementi
  b.sum(axis=0)   # somma in colonna
  b.sum(axis=1)   # somma in righe

Anche numpy ha il proprio generatore di numeri causali

4.py

  import numpy.random as np_r
  rng = np_r.default_rng()
  vals = rng.standard_normal(10)
  more_vals = rng.standard_normal(10)

Non esistono puntatori, ma si usano!

  >>> a = np.array([2,3,4])
  >>> b = a                # b punta ad a, esiste un solo array
  >>> b is a
  True
  >>> print(id(a))
  >>> print(id(b))

  >>> c=a.view() # le viste sono una copia, con id diverso
  >>> c = a[:, :] # COPIA cioe' crea una view!

Modificando i dati di A, si modifica anche C! Modificando i dati di C, si modifica anche A! Modificando gli attributi (flag) di C NON si modificano i parametri di A!

  >>> d = a.copy()
  >>> e = a[:,9].copy() # copia parziale

  >>> a = np.arange(12)**2                       # the first 12 square numbers
  >>> i = np.array([1, 1, 3, 8, 5])              # an array of indices
  >>> a[i]                                       # the elements of a at the positions i
  array([ 1,  1,  9, 64, 25])