#!/usr/bin/python -tt #======= #Crediti #======= # esercizi corso di python @ifac-cnr # Copyright 2012 Nicola ZOppetti # Licensed under the Apache License, Version 2.0 # http://www.apache.org/licenses/LICENSE-2.0 #==================== #Indicazioni generali #==================== # RIEMPIRE LE FUNZIONI # DOVE COMPARE IL COMMENTO # ##-METTI-QUI-IL-TUO-CODICE-## # Seguire le istruzioni riportate nel commento # precedente ciascuna funzione da riempire # Una volta studiata una soluzione ad un esercizio, # per verificare se è corretta eseguire QUESTO SCRIPT # # Per un generico 'esercizio 1', se la soluzione è errata o non data # sullo standard output viene stampato il prefisso KO, il valore restituito e quello atteso # >>> esercizio 1 # >>> KO restituisce: None, risultato atteso: [98, 55, 10, 8, 2] # # Se la soluzione è corretta: # sullo standard output viene stampato OK # >>> esercizio 1 # >>> OK #=============== #INIZIO ESERCIZI #=============== import numpy as np # --------------------- # def arraydistanze(d) # -------------------- # sia d un array monodimensionale ordinato di n elementi (numerici) che rappresentano la distanza in km # tra l'inizio di una strada e un certo numero di punti di riferimento # incontrati lungo di essa. # restituire un array bidimensionale di nxn elementi che rappresenta le mutue distanze tra i punti di riferimento # in modo che nella calla i,j ci sia la distanza tra l'i-esimo ed il j-esimo punto # implementare usando broadcasting !!!!! # Esempio: # >>>arraydistanze0(np.array([0 , 12 , 45 , 55 , 89 ,198])) # [[ 0 12 45 55 89 198] # [ 12 0 33 43 77 186] # [ 45 33 0 10 44 153] # [ 55 43 10 0 34 143] # [ 89 77 44 34 0 109] # [198 186 153 143 109 0]] def arraydistanze(d): ##-METTI-QUI-IL-TUO-CODICE-## return # ------------------------- # def distanzeorigine(x,y): # ------------------------- # x e y sono due array monodimensionali che contengono le coordinate x ed y che definiscono # una griglia regolare di punti sul piano (non necessariamente quadrata) # # retituire un array 2D che contiene le distanze # di ciascun punto della griglia dall'origine # # implementare usando broadcasting !!!!! # # Esempio: # >>> distanzeorigine0( np.array([0,1,2,3]) , np.array([0,1]) ) # [[ 0. 1. 2. 3. ] # [ 1. 1.41421356 2.23606798 3.16227766]] def distanzeorigine(x,y): ##-METTI-QUI-IL-TUO-CODICE-## return # ------------------------- # def mutuedistanze(x,y): # ------------------------- # x e y sono due array monodimensionali che contengono l # e coordinate x ed y di un insieme di punti # (il numero di punti è definito dalla lunghezza dell'array # più corto, scartare le coordinate in più del più lungo) # # retituire un array 2D che contiene le mutue distanze # tra ciascuna coppia di punti # # implementare usando broadcasting !!!!! # # Esempi: # >>> mutuedistanze( np.array([0,1,2,3]) , np.array([0,1]) ) # [[ 0. 1.41421356] # [ 1.41421356 0. ]] # # >>> mutuedistanze( np.array([0,1,2,3]) , np.array([2,3]) ) # [[ 0. 1.41421356] # [ 1.41421356 0. ]] # >>> mutuedistanze( np.array([0,1,2,3,4]) , np.array([2,2,2,2,2]) ) # [[ 0. 1. 2. 3. 4.] # [ 1. 0. 1. 2. 3.] # [ 2. 1. 0. 1. 2.] # [ 3. 2. 1. 0. 1.] # [ 4. 3. 2. 1. 0.]] # # >>> mutuedistanze( np.array([0,1,2,3]) , np.array([0,10,20]) ) # [[ 0. 10.04987562 20.09975124] # [ 10.04987562 0. 10.04987562] # [ 20.09975124 10.04987562 0. ]] def mutuedistanze(x,y): ##-METTI-QUI-IL-TUO-CODICE-## return # #(6+3) # ------------------------- # def distanzeorigine3D(x,y,z): # ------------------------- # x y z sono tre array monodimensionali che contengono le coordinate x y z che definiscono # una griglia regolare di punti nello spazio (non necessariamente cubica) # # retituire un array 3D che contiene le distanze # di ciascun punto della griglia dall'origine # # implementare usando broadcasting !!!!! # # Esempio: # >>> distanzeorigine3D( np.array([0,1]) , np.array([0,1,2]) , np.array([0,1,2,3])) ) ##[[[ 0. 1. ] ## [ 1. 1.41421356] ## [ 2. 2.23606798]] ## ## [[ 1. 1.41421356] ## [ 1.41421356 1.73205081] ## [ 2.23606798 2.44948974]] ## ## [[ 2. 2.23606798] ## [ 2.23606798 2.44948974] ## [ 2.82842712 3. ]] ## ## [[ 3. 3.16227766] ## [ 3.16227766 3.31662479] ## [ 3.60555128 3.74165739]]] def distanzeorigine3D(x,y,z): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- # def dividi_x_colonna(a,b): #--------------------------- # a è un array 2D nxn # [ [a11 a12 a13 ... a1n] # [a21 a22 a23 ... a2n] # ... # [an1 an2 an3 ... ann]] # # b è un array 1D di n elementi # [ b1 b2 ... bn] # # restituire un array di nxn elementi # [ [a11/b1 a12/b2 a13/b3 ... a1n/bn] # [a21/b1 a22/b2 a23/b3 ... a2n/bn] # ... # [an1/b1 an2/b2 an3/b3 ... ann/bn]] def dividi_x_colonna(a,b): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- #def primasuperdiagonale(a) #--------------------------- # a è un array 2D # restituire la prima superdiagonale di a # Esempi: # >>> a = np.array([[0, 1, 2, 3], # [5, 6, 7, 8], # [11, 12, 13, 14], # [15, 16, 17, 18], # [19, 20, 21, 22]]) # >>> primasuperdiagonale(a) # [1 7 14] def primasuperdiagonale(a): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- # def colonna01(stop,step): #--------------------------- # restituire l'array 2D con interi di 4 byte strutturati in una singola colonna # i dati partono da 0 e arrivano al più grande multiplo di step inferiore a stop # Esempio: # >>>colonna01(43,3) # array([[ 0], # [ 3], # [ 6], # [ 9], # [12], # [15], # [18], # [21], # [24], # [27], # [30], # [33], # [36], # [39], # [42]]) def colonna01(stop,step): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- # def azzera01(a) #--------------------------- # dato un array 3D a # azzerare gli elementi del secondo piano che non stanno sui bordi: # Esempi: # >>>a = azzera01(np.arange(3*4*5).reshape(3,4,5)) # >>>a #array([[[ 0, 1, 2, 3, 4], # [ 5, 6, 7, 8, 9], # [10, 11, 12, 13, 14], # [15, 16, 17, 18, 19]], # # [[20, 21, 22, 23, 24], # [25, 0, 0, 0, 29], # [30, 0, 0, 0, 34], # [35, 36, 37, 38, 39]], # # [[40, 41, 42, 43, 44], # [45, 46, 47, 48, 49], # [50, 51, 52, 53, 54], # [55, 56, 57, 58, 59]]]) # # >>>a = azzera01(a=np.arange(2*3*4).reshape(2,3,4)) #array([[[ 0, 1, 2, 3], # [ 4, 5, 6, 7], # [ 8, 9, 10, 11]], # # [[12, 13, 14, 15], # [16, 0, 0, 19], # [20, 21, 22, 23]]]) def azzera01(a): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- # def componi_row(a,b,c): #--------------------------- # dati 3 vettori a b c restituire l'array che ha per righe i 3 vettori # se i vettori hanno lunghezze diverse limitarsi a un numero di colonne pari al minimo # numero di elementi #>>> componi_row( np.arange(3),np.arange(4,8),np.arange(10,16)) #array([[ 0, 1, 2], # [ 3, 4, 5], # [10, 11, 12]]) def componi_row(a,b,c): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- # def componi_col(a,b,c): #--------------------------- # dati 3 vettori a b c restituire l'array che ha per righe i 3 vettori # se i vettori hanno lunghezze diverse limitarsi a un numero di colonne pari al minimo # numero di elementi #>>> componi_col( np.arange(3),np.arange(4,8),np.arange(10,16)) #array([[ 0, 3, 10], # [ 1, 4, 11], # [ 2, 5, 12]]) def componi_col(a,b,c): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- #def triangolare(n,val): #--------------------------- # restituire la matrice l'array n x n #dove tutti gli elementi del triangolo inferiore (diagonale compresa) valgono val #e tutti gli altri valgono 0 # #Esempi: ##>>> triangolare(5,2) ##array([[ 2., 0., 0., 0., 0.], ## [ 2., 2., 0., 0., 0.], ## [ 2., 2., 2., 0., 0.], ## [ 2., 2., 2., 2., 0.], ## [ 2., 2., 2., 2., 2.]]) ##>>> triangolare(3,3) ##array([[ 3., 0., 0.], ## [ 3., 3., 0.], ## [ 3., 3., 3.]]) def triangolare(n,val): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- #def specchiacol(a):: #--------------------------- # dato un array 2D a # restituisce una copia di a in cui gli elementi # delle righe sono invertiti di ordine # # Esempi: ##>>> a ##array([[11, 3, 4, 0], ## [11, 15, 6, 20], ## [ 9, 4, 18, 20], ## [ 1, 15, 3, 5], ## [11, 13, 6, 20]]) ##>>> specchiacol(a) ##array([[ 0, 4, 3, 11], ## [20, 6, 15, 11], ## [20, 18, 4, 9], ## [ 5, 3, 15, 1], ## [20, 6, 13, 11]]) ##>>> specchiacol(np.arange(3*4).reshape(3,4)) ##array([[ 3, 2, 1, 0], ## [ 7, 6, 5, 4], ## [11, 10, 9, 8]]) ##>>> specchiacol(np.arange(3*7).reshape(3,7)) ##array([[ 6, 5, 4, 3, 2, 1, 0], ## [13, 12, 11, 10, 9, 8, 7], ## [20, 19, 18, 17, 16, 15, 14]]) ##>>> specchiacol(np.arange(5*3).reshape(5,3)) ##array([[ 2, 1, 0], ## [ 5, 4, 3], ## [ 8, 7, 6], ## [11, 10, 9], ## [14, 13, 12]]) def specchiacol(a): ##-METTI-QUI-IL-TUO-CODICE-## return #--------------------------- #def specchiarow(a):: #--------------------------- # dato un array 2D a # restituisce una copia di a in cui gli elementi # sono ribaltati specularmente per colonna # ##>>> a ##array([[18, 5, 5, 20], ## [12, 4, 14, 10], ## [ 0, 7, 2, 9], ## [ 2, 19, 2, 1], ## [ 5, 2, 10, 9]]) ##>>> specchiarow(a) ##array([[ 5, 2, 10, 9], ## [ 2, 19, 2, 1], ## [ 0, 7, 2, 9], ## [12, 4, 14, 10], ## [18, 5, 5, 20]]) ##>>> specchiarow(np.arange(15).reshape(5,3)) ##array([[12, 13, 14], ## [ 9, 10, 11], ## [ 6, 7, 8], ## [ 3, 4, 5], ## [ 0, 1, 2]]) def specchiarow(a): ##-METTI-QUI-IL-TUO-CODICE-## return #============== # FINE ESERCIZI #============== # NON MODIFICARE DA QUI IN POI!!!!!!!! # FUNZIONE test() usata in main() per stampare # cosa restituisce ciascuna funzione vs. cosa dovrebbe restituire quella corretta def test(got, expected): if got == expected: prefix = 'OK ' print('OK') else: prefix = 'KO ' print('%s restituisce: %s, risultato atteso: %s' % (prefix, repr(got), repr(expected))) def testnparray(got, expected): if (got != None) and (got.dtype == expected.dtype) and np.array_equal(got,expected) : prefix = 'OK ' print('OK') else: prefix = 'KO' print('%s\n restituisce:\n %s \n risultato atteso:\n %s' % (prefix, repr(got), repr(expected))) def testnparrayequal(got, expected,tol=1e-6): if (got == None) or (got.dtype != expected.dtype) or np.any(np.abs(got-expected))>tol : prefix = 'KO' print('%s\n restituisce:\n %s \n risultato atteso:\n %s' % (prefix, repr(got), repr(expected))) return else: prefix = 'OK ' print('OK') return def testnparraynotequal(got, expected): if (got != None) and (got.dtype == expected.dtype) and np.all(got==expected): prefix = 'OK ' print('OK') return else: prefix = 'KO' print('%s\n restituisce:\n %s \n risultato atteso:\n %s' % (prefix, repr(got), repr(expected))) return def test_float(got,expected,eps=1.e-6): if got == None: print('KO restituisce: None, risultato atteso: %s' % (repr(expected))) return if abs(got-expected)< eps: prefix = 'OK ' print('OK') else: #print('KO') prefix = 'KO ' print('%s restituisce: %s, risultato atteso: %s' % (prefix, repr(got), repr(expected))) # chiama le funzioni-soluzione con argomenti fissati e # confronta i risultati con quelli attesi def main(): print('') print('arraydistanze') d=np.array([0 , 12 , 45 , 55 , 89 ,198]) dsol=np.array([[0, 12, 45, 55, 89, 198], [12, 0, 33, 43, 77, 186], [45, 33, 0, 10, 44, 153], [55, 43, 10, 0, 34, 143], [89, 77, 44, 34, 0, 109], [198, 186, 153, 143, 109, 0]]) testnparray(arraydistanze(d),dsol) print('') print('distanzeorigine') testnparrayequal(distanzeorigine(np.array([0,1,2,3]),np.array([0,10,20])), np.array([[0.0, 1.0, 2.0, 3.0], [10.0, 10.04987562112089, 10.198039027185569, 10.44030650891055], [20.0, 20.024984394500787, 20.09975124224178, 20.223748416156685]])) print('') print('mutuedistanze') testnparrayequal(mutuedistanze(np.array([0,1,2,3]),np.array([0,10,20])), np.array([[0.0, 10.04987562112089, 20.09975124224178], [10.04987562112089, 0.0, 10.04987562112089], [20.09975124224178, 10.04987562112089, 0.0]])) testnparrayequal(mutuedistanze(np.array([0,1,2,3,4]) , np.array([2,2,2,2,2])), np.array([[0.0, 1.0, 2.0, 3.0, 4.0], [1.0, 0.0, 1.0, 2.0, 3.0], [2.0, 1.0, 0.0, 1.0, 2.0], [3.0, 2.0, 1.0, 0.0, 1.0], [4.0, 3.0, 2.0, 1.0, 0.0]])) print('') print('distanzeorigine3D') testnparrayequal(distanzeorigine3D(np.array([0,1]),np.array([0,1,2]),np.array([0,1,2,3])), np.array([[[0.0, 1.0], [1.0, 1.4142135623730951], [2.0, 2.23606797749979]], [[1.0, 1.4142135623730951], [1.4142135623730951, 1.7320508075688772], [2.23606797749979, 2.449489742783178]], [[2.0, 2.23606797749979], [2.23606797749979, 2.449489742783178], [2.8284271247461903, 3.0]], [[3.0, 3.1622776601683795], [3.1622776601683795, 3.3166247903554], [3.605551275463989, 3.7416573867739413]]])) print('') print('dividi_x_colonna') testnparrayequal(dividi_x_colonna(np.arange(25).reshape(5,5),np.arange(1,6)), np.array([[0.0, 1.0, 2.0, 3.0, 4.0], [2.5, 3.0, 3.5, 4.0, 4.5], [3.3333333333333335, 3.6666666666666665, 4.0, 4.333333333333333, 4.666666666666667], [3.75, 4.0, 4.25, 4.5, 4.75], [4.0, 4.2, 4.4, 4.6, 4.8]])) print('') print('primasuperdiagonale') a = np.array([ [0, 1, 2, 3], [5, 6, 7, 8], [11, 12, 13, 14], [15, 16, 17, 18], [19, 20, 21, 22]]) testnparrayequal(primasuperdiagonale(a),np.array([1,7,14])) testnparrayequal(primasuperdiagonale(np.arange(6*7).reshape(6,7)),np.array([ 1 , 9, 17 ,25, 33 ,41])) print('') print('colonna01') testnparray(colonna01(43,3),np.array([[ 0],[ 3],[ 6], [ 9], [12],[15],[18],[21],[24],[27],[30],[33],[36],[39],[42]])) print('') print('azzera01') a=np.arange(3*4*5).reshape(3,4,5) azzera01(a) testnparray(a,np.array([[[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]], [[20, 21, 22, 23, 24], [25, 0, 0, 0, 29], [30, 0, 0, 0, 34], [35, 36, 37, 38, 39]], [[40, 41, 42, 43, 44], [45, 46, 47, 48, 49], [50, 51, 52, 53, 54], [55, 56, 57, 58, 59]]])) a=np.arange(2*3*4).reshape(2,3,4) azzera01(a) testnparray(a,np.array([[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], [16, 0, 0, 19], [20, 21, 22, 23]]])) print('') print('componi_row') testnparray(componi_row( np.arange(3),np.arange(4,8),np.arange(10,16)),np.array([[ 0, 1, 2], [ 4, 5, 6], [10, 11, 12]])) print('') print('componi_col') testnparray(componi_col( np.arange(3),np.arange(4,8),np.arange(10,16)), np.array([[ 0, 4, 10], [ 1, 5, 11], [ 2, 6, 12]])) print('') print('triangolare') testnparray(triangolare(5,2),np.array([[ 2., 0., 0., 0., 0.], [ 2., 2., 0., 0., 0.], [ 2., 2., 2., 0., 0.], [ 2., 2., 2., 2., 0.], [ 2., 2., 2., 2., 2.]])) print('') print('specchiacol') a=np.array([[11, 3, 4, 0], [11, 15, 6, 20], [ 9, 4, 18, 20], [ 1, 15, 3, 5], [11, 13, 6, 20]]) testnparray(specchiacol(a), np.array([[ 0, 4, 3, 11], [20, 6, 15, 11], [20, 18, 4, 9], [ 5, 3, 15, 1], [20, 6, 13, 11]])) testnparray(specchiacol(np.arange(3*4).reshape(3,4)),np.array([[ 3, 2, 1, 0], [ 7, 6, 5, 4], [11, 10, 9, 8]])) testnparray(specchiacol(np.arange(3*7).reshape(3,7)),np.array([[ 6, 5, 4, 3, 2, 1, 0], [13, 12, 11, 10, 9, 8, 7], [20, 19, 18, 17, 16, 15, 14]])) testnparray(specchiacol(np.arange(5*3).reshape(5,3)),np.array([[ 2, 1, 0], [ 5, 4, 3], [ 8, 7, 6], [11, 10, 9], [14, 13, 12]])) print('') print('specchiarow') a=np.array([[18, 5, 5, 20], [12, 4, 14, 10], [ 0, 7, 2, 9], [ 2, 19, 2, 1], [ 5, 2, 10, 9]]) testnparray(specchiarow(a),np.array([[ 5, 2, 10, 9], [ 2, 19, 2, 1], [ 0, 7, 2, 9], [12, 4, 14, 10], [18, 5, 5, 20]])) testnparray(specchiarow(np.arange(5*3).reshape(5,3)),np.array([[12, 13, 14], [ 9, 10, 11], [ 6, 7, 8], [ 3, 4, 5], [ 0, 1, 2]])) ########################################## # Standard boilerplate to call the main() function. if __name__ == '__main__': main()