'''
Le operazioni fra matrici sono tra le operazioni piu' comuni in molti ambiti
delle scienze. Per questo e' molto importante sapere in cosa consistono
a livello di singolo elemento.

In questo esercizio si devono implementare le operazioni considerando le matrici
come liste di liste.

Per cui la matrice

    | 2  0   -4 |
A = | 5  10  20 |
    | 5  1   -1 |

sara' rappresentata come [[2,0,-4],[5,10,20],[5,1,-1]]

Implementare le seguenti funzioni:

somma fra matrici:
A+B=C dove C[i][j]=A[i][j]+B[i][j] per ogni i e j
| 1  3 |   | 5  6 |   | 6  9 |
|-1  6 | + |-1  5 | = | -2 11|

prodotto di una matrice per uno scalare:
a*A=C dove C[i][j]=a*A[i][j]
    | 1  3 |   | 5  15|
5 * |-1  6 | = |-5  30|

matrice trasposta:
At[i][j]=A[j][i]


prodotto fra matrici:
A*B=C dove C[i][j]=somma(A[i][x]*B[x][j]) per ogni x
| 1  3 |   | 5  6 |   | 2  21|
|-1  6 | * |-1  5 | = |-11 24|

vettore dei massimi/minimi(*) per riga, colonna, diagonale su, diagonale giù:
se 
    | 2  0   -4 |
A = | 5  10  20 |
    | 5  1   -1 |

(*)eventualmente si possono aggiungere somma, prodotto, media, moda o mediana

vec('max','row',A)= | 2  20 5 |
vec('min','row',A)= |-4  5  -1|
vec('max','col',A)= | 5  10 20|
vec('min','col',A)= | 2   0 -4|
vec('max','dgi',A)= |10  20  5|
vec('min','dgi',A)= |-1   0 -4|
vec('max','dsu',A)= |10  20  5|
vec('min','dsu',A)= |-4   1 -1|

rimuovi riga e rimuovi colonna
Es:
Rimuovi riga 2:
    | 2  0   -4 |         | 2  0   -4 |
A = | 5  10  20 | -> A' = | 5  1   -1 |
    | 5  1   -1 |         


scambia righe e scambia colonne

Es:
Scambia riga 1 con riga 3
    | 2  0   -4 |         | 5  1   -1 |
A = | 5  10  20 | -> A' = | 5  10  20 |
    | 5  1   -1 |         | 2  0   -4 |

Calcolo del determinante? -> Si può chiedere soluzione con ricorsione.
Aggiungerei nel pacchetto la pagina web
http://www.youmath.it/lezioni/algebra-lineare/matrici-e-vettori/767-calcolo-del-determinante.html

Calcolo dell'inversa??
'''
import numpy as np
def sizeof(A):
    return len(A), len(A[0])

def somma (A, B):
    # Qui il codice #
    sa=sizeof(A)
    sb=sizeof(B)
    C=[]
    if sb == sa:
        for i,row in enumerate(A):
            newrow=[]
            for j,el in enumerate(row):
                newrow.append(el+B[i][j])
            C.append(newrow)
    return C
   

def scalprod (a, A):
    # Qui il codice #
    C=[]
    for row in A:
        newrow=[]
        for el in row:
            newrow.append(a*el)
        C.append(newrow)
    return C


def matprod (A,B):
    # Qui il codice #
    sa=sizeof(A)
    sb=sizeof(B)
    C=[]
    if sb == sa:
        for i in range(sa[0]):
            newrow=[]
            for j in range(sa[1]):
                newrow.append(sum([A[i][x]*B[x][j] for x in range(sa[1])]))
            C.append(newrow)
    return C
    
    
def vec(op, sel, A):
    ''' op vale "min" o "max" a seconda dell'operazione richiesta
        mentre sel  vale "col", "row", "dgi" o "dsu" a seconda se si
        vuole l'operazione per colonna, riga, diagonale verso il basso
        o diagonale verso l'alto, rispettivamente'''
    # Qui il codice #
    if op in ('min','max') and sel in ("col", "row", "dgi","dsu"):
        i,j=sizeof(A)
        v=[]
        if sel == 'col':
            for y in range(j):
                v.append(eval(op)([A[x][y] for x in range(i)]))
        if sel == 'row':
            for x in range(i):
                v.append(eval(op)([A[x][y] for y in range(j)]))
        if sel == 'dgi':
            for y in range(j):
                v.append(eval(op)([A[x][(x+y)%j] for x in range(i)]))
        if sel == 'dsu':
            for y in range(j):
                v.append(eval(op)([A[i-x-1][(x+y)%j] for x in range(i)]))
        return v

        
def trasponi(A):
    # Qui il codice #
    i,j=sizeof(A)
    B=[]
    for y in range(j):
        B.append([A[x][y] for x in range(i)])
    return B
            

def rimuovi(sel, n, A):
    ''' sel vale "col" o "row" a seconda se si deve eliminare
        la colonna n o la riga n dalla matrice A'''
    # Qui il codice #
    C=[A[i][:] for i in range(len(A))]
    if sel=='row':
        del C[n]
    if sel=='col':
        for i in range(len(A)):
            del C[i][n]
    return C

def scambia(sel, m, n, A):
    ''' sel vale "col" o "row" a seconda se si deve scambiare
        la colonna o la riga m con la n dalla matrice A'''
    # Qui il codice #
    C=[A[i][:] for i in range(len(A))]
    if sel == 'row':
        v=C[m][:]
        C[m]=C[n][:]
        C[n]=v[:]
    if sel == 'col':
        for i in range(len(C)):
            v=C[i][m]
            C[i][m]=C[i][n]
            C[i][n]=v
    return C
        
def det(A):
    # Qui il codice #
    i,j=sizeof(A)
    if i!=j:
        return None
    if i==2:
        return A[0][0]*A[1][1]-A[1][0]*A[0][1]
    if i==3:
        res=A[0][0]*A[1][1]*A[2][2]+A[1][0]*A[2][1]*A[0][2]+A[2][0]*A[0][1]*A[1][2]
        res-=A[2][0]*A[1][1]*A[0][2]+A[2][1]*A[1][2]*A[0][0]+A[2][2]*A[1][0]*A[0][1]
        return res
    maxc=0
    maxi=0
    for i in range(len(A)):
        c=A[i].count(0)
        if c> maxc:
            maxi=i
    x=maxi
    C=rimuovi('row',x,A)
    return sum([(-1)**(x+y)*A[x][y]*det(rimuovi('col',y,C)) for y in range(j)])

if __name__ == '__main__':
    A=[[2,0,-4],[5,10,20],[5,1,-1]]
    B=[[2,0,-4],[5,10,20],[5,1,-1]]
    C=somma(A,B)
    print(*C,sep='\n')
    print()
    C=scalprod(2,A)
    print(*C,sep='\n')
    print()
    v=vec('max','col',A)
    print(v)
    A=[[2,0,-4],[5,10,20],[30,1,-1]]
    v=vec('max','dgi',A)
    print(v)
    v=vec('max','dsu',A)
    print(v)
    print()
    C=trasponi(A)
    print(*C,sep='\n')
    print()

    C=rimuovi('row', 1, A)
    print(*C,sep='\n')
    print()

    C=rimuovi('col', 1, A)
    print(*C,sep='\n')
    print()

    C=scambia('row', 0,1,A)
    print(*C,sep='\n')
    print()
    
    C=scambia('col', 0,2,A)
    print(*C,sep='\n')
    print()

    print(det(A))
    print(np.linalg.det(np.array(A)))
    A=[[1,3],[-1,6]]
    B=[[5,6],[-1,5]]
    C=matprod(A,B)
    print(C)
    print(det(C))
    print(np.linalg.det(np.array(C)))