# -*- coding: utf-8 -*-
"""
TD n°6 --- L'essentiel du module numpy

Une section par diapo de EssentielTD6.pdf.
Le fichier s'execute jusqu'au bout : les instructions qui provoquent
une erreur sont protegees ou mises en commentaire.
"""

import numpy as np
import numpy.linalg as la


def titre(texte):
    print()
    print("=" * 60)
    print(texte)
    print("=" * 60)


# =====================================================================
titre("1. Creer un tableau")
# =====================================================================

A = np.array([[1, 2], [3, 4]])
print(A)
print(np.zeros([2, 3]))         # matrice nulle 2 x 3 (flottants)
print(np.eye(3))                # identite I_3
print(np.diag([1, 2, 3]))       # matrice diagonale
print(np.linspace(0, 1, 5))     # [0.   0.25 0.5  0.75 1.  ]

# Tous les coefficients ont le meme type
B = np.array([[1, 2], [3, 4]])          # tableau d'entiers
B[0, 0] = 2.7
print(B)                                # [[2 2] [3 4]] : 2.7 tronque en 2 !
B = np.array([[1., 2.], [3., 4.]])      # tableau de flottants
B[0, 0] = 2.7
print(B)                                # [[2.7 2. ] [3.  4. ]]


# =====================================================================
titre("2. Lire dans un tableau : les indices commencent a 0")
# =====================================================================

R = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(R[1, 2])          # 7  : ligne 1, colonne 2 (a_{2,3} en maths)
print(R[0])             # [1 2 3 4]   ligne 0
print(R[:, 1])          # [ 2  6 10]  colonne 1
print(R[-1])            # [ 9 10 11 12]  derniere ligne
print(R[0:2, 1:3])      # [[2 3] [6 7]] : lignes 0-1, colonnes 1-2
n, p = np.shape(R)
print(n, p)             # 3 4
print(np.size(R))       # 12
# print(R[3, 0])        # IndexError : il n'y a que les lignes 0, 1, 2

# Parcours de tous les coefficients : i sur les lignes, j sur les colonnes
s = 0
for i in range(n):
    for j in range(p):
        s = s + R[i, j]
print(s, np.sum(R))     # 78 78

# Remarque : avec une liste de listes, c'est different
L = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
print(L[1][2])                      # 7 : syntaxe des listes
# print(L[1, 2])                    # TypeError : la syntaxe [i, j] est reservee a numpy
print(L[1])                         # [5, 6, 7, 8] : ligne 1
print([ligne[2] for ligne in L])    # [3, 7, 11] : colonne 2
print(len(L), len(L[0]))            # 3 4 : nombre de lignes, de colonnes (pas de np.shape)
print(R[1][2])          # 7 : sur un tableau numpy, R[1][2] marche aussi, mais on ecrit R[1, 2]


# =====================================================================
titre("3. Modifier un tableau : copies et vues")
# =====================================================================

Z = np.zeros([3, 4])
Z[0, 0] = 5             # un coefficient
Z[1, :] = 1             # toute la ligne 1
Z[:, 3] = [7, 8, 9]     # toute la colonne 3
Z[2, 0:2] = 4           # un morceau de la ligne 2
print(Z)
# [[5. 0. 0. 7.]
#  [1. 1. 1. 8.]
#  [4. 4. 0. 9.]]

# C = B ne copie pas : deux noms pour le meme tableau
B = np.array([[1, 2], [3, 4]])
C = B
C[1, 1] = 0
print(B)                # [[1 2] [3 0]] : B a ete modifie !

B = np.array([[1, 2], [3, 4]])
C = np.copy(B)          # vraie copie
C[1, 1] = 0
print(B)                # [[1 2] [3 4]] : B intact

# M[0] est une VUE sur M : l'echange "a la Python" echoue
M = np.array([[1., 2., 1.], [2., 3., 1.], [1., 1., 2.]])
M[0], M[1] = M[1], M[0]
print(M)                # deux fois [2. 3. 1.] : la ligne 0 est perdue


def echange_lignes(M, i, j):
    """Echange les lignes i et j de M (modifie M, ne renvoie rien)."""
    L = np.copy(M[i])
    M[i] = M[j]
    M[j] = L


def transvection(M, i, j, a):
    """Li <- Li + a Lj (modifie M, ne renvoie rien)."""
    M[i] = M[i] + a * M[j]


M = np.array([[1., 2., 1.], [2., 3., 1.], [1., 1., 2.]])
echange_lignes(M, 0, 1)
print(M)                # lignes 0 et 1 bien echangees

M = np.array([[1., 2., 1.], [2., 3., 1.], [1., 1., 2.]])
transvection(M, 1, 0, -2)       # L2 <- L2 - 2 L1
transvection(M, 2, 0, -1)       # L3 <- L3 - L1
transvection(M, 2, 1, -1)       # L3 <- L3 - L2
print(M)                # triangulaire superieure, diagonale 1, -1, 2


# =====================================================================
titre("4. Calculer : * n'est pas le produit matriciel")
# =====================================================================

A = np.array([[1, 2], [3, 4]])
B = np.array([[0, 1], [1, 0]])
print(A + B)            # [[1 3] [4 4]]
print(3 * A)            # [[ 3  6] [ 9 12]]
print(A * B)            # [[0 2] [3 0]]      coefficient par coefficient
print(np.dot(A, B))     # [[2 1] [4 3]]      produit matriciel AB
print(A @ B)            # idem
print(np.dot(B, A))     # [[3 4] [1 2]]      BA est different de AB
print(A ** 2)           # [[ 1  4] [ 9 16]]  chaque coefficient au carre
print(np.dot(A, A))     # [[ 7 10] [15 22]]  la vraie matrice A^2
print(np.transpose(A))  # ou A.T
print(np.sum(A), np.prod(A), np.max(A), np.min(A))   # 10 24 4 1
print(np.sum(A[:, 0]))  # 4 : somme de la colonne 0


def puissance(A, n):
    """A^n, avec A^0 = I."""
    P = np.eye(np.shape(A)[0])
    for k in range(n):
        P = np.dot(P, A)
    return P


print(puissance(A, 0))  # identite
print(puissance(A, 3))  # [[ 37.  54.] [ 81. 118.]]


# =====================================================================
titre("5. Comparer des tableaux")
# =====================================================================

print(A == B)           # un TABLEAU de booleens, pas True/False


def egales(A, B):
    """True si A et B ont le meme format et les memes coefficients."""
    if np.shape(A) != np.shape(B):
        return False
    n, p = np.shape(A)
    for i in range(n):
        for j in range(p):
            if A[i, j] != B[i, j]:
                return False
    return True


print(egales(A, A))                                     # True
print(egales(np.dot(A, B), np.dot(B, A)))               # False : AB != BA
print(egales(A, np.array([[1, 2, 3], [3, 4, 5]])))      # False : formats differents
print(egales(np.transpose(np.dot(A, B)),
             np.dot(np.transpose(B), np.transpose(A)))) # True : (AB)^T = B^T A^T
# Pour aller plus loin : all et any (A et B doivent avoir le meme format)
print(np.all(A == A))   # True  : tous les coefficients sont egaux
print(np.all(A == B))   # False
print(np.any(A == B))   # False : aucun coefficient egal
print(np.any(A == np.array([[1, 0], [0, 0]])))   # True : le coefficient 1 est commun
print((A == A).all())   # True : meme chose que np.all(A == A)


# =====================================================================
titre("6. Des fonctions sur les matrices")
# =====================================================================

def produit(A, B):
    """AB calcule avec la formule (AB)_ij = somme sur k de a_ik b_kj."""
    n, p = np.shape(A)
    q = np.shape(B)[1]
    C = np.zeros([n, q])
    for i in range(n):
        for j in range(q):
            for k in range(p):
                C[i, j] = C[i, j] + A[i, k] * B[k, j]
    return C


U = np.array([[1, 2, 3], [4, 5, 6]])        # 2 x 3
V = np.array([[1, 0], [0, 1], [2, 2]])      # 3 x 2
print(produit(U, V))                        # 2 x 2 : [[ 7.  8.] [16. 17.]]
print(np.dot(U, V))                         # meme resultat
print(np.shape(produit(V, U)))              # (3, 3)


def est_symetrique(A):
    """Version courte : A est egale a sa transposee."""
    return egales(A, np.transpose(A))


def est_symetrique_boucle(A):
    """Version avec une double boucle : a_ij = a_ji pour tous i, j."""
    n, p = np.shape(A)
    if n != p:
        return False                # une matrice symetrique est carree
    for i in range(n):
        for j in range(i):          # sous la diagonale suffit : (j, i) est le symetrique
            if A[i, j] != A[j, i]:  # et la diagonale est toujours bonne
                return False        # un contre-exemple suffit
    return True                     # apres TOUTES les boucles


def est_triangulaire_sup(A):
    n = np.shape(A)[0]
    for i in range(n):
        for j in range(i):          # coefficients sous la diagonale : j < i
            if A[i, j] != 0:
                return False        # un contre-exemple suffit
    return True                     # apres TOUTES les boucles


S = np.array([[1, 2], [2, 5]])
print(est_symetrique(S), est_symetrique(A))         # True False
print(est_symetrique_boucle(S), est_symetrique_boucle(A))   # True False
print(est_symetrique_boucle(U))                     # False : U n'est pas carree

T = np.array([[1, 2], [0, 3]])
print(est_triangulaire_sup(T), est_triangulaire_sup(A))   # True False


# "Pour tout" : return False des qu'un cas echoue, return True apres les boucles.
# "Il existe" : on inverse True et False.
def contient_zero(A):
    """True s'il existe i, j tels que a_ij = 0."""
    n, p = np.shape(A)
    for i in range(n):
        for j in range(p):
            if A[i, j] == 0:
                return True         # un exemple suffit
    return False                    # apres TOUTES les boucles


print(contient_zero(T), contient_zero(A))   # True False


# =====================================================================
titre("7. numpy.linalg : inverse, systeme, rang")
# =====================================================================

P = np.array([[2, 1], [1, 1]])
print(la.inv(P))        # [[ 1. -1.] [-1.  2.]]

M = np.array([[1, 2, 1], [2, 3, 1], [1, 1, 2]])
print(la.matrix_rank(M))    # 3 : M est inversible

# Systeme  x + 2y + z = 1 ; 2x + 3y + z = 1 ; x + y + 2z = 4,  soit MX = Y
Y = np.array([1, 1, 4])
X = np.dot(la.inv(M), Y)
print(X)                # [ 1. -1.  2.]  (a des arrondis pres)
print(np.dot(M, X))     # verification : on retrouve Y

J = np.ones([4, 4])
print(la.matrix_rank(J))    # 1
# print(la.inv(J))          # LinAlgError: Singular matrix -> arrete le programme
try:
    print(la.inv(J))
except la.LinAlgError as e:
    print("Erreur :", e)

# Remarque : limites de la.inv et la.matrix_rank (calculs approches sur des flottants)
N = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(la.matrix_rank(N))    # 2 : C1 - 2 C2 + C3 = 0, N n'est pas inversible
try:
    print(la.inv(N))        # souvent aucune erreur... mais des coefficients enormes (~1e16)
except la.LinAlgError as e:
    print("Erreur :", e)

# D_h = [[1, 1], [1, 1 + h]] est de rang 2 pour tout h != 0
for k in range(10, 18):
    h = 10 ** (-k)
    D = np.array([[1, 1], [1, 1 + h]])
    print("h = 1e-" + str(k), " rang calcule :", la.matrix_rank(D))
# rang 2 jusqu'a h = 1e-14, puis 1 : la machine ne "voit" plus h
# Conclusion : un rang ou une inversibilite se justifie sur papier.
