# -*- coding: utf-8 -*- """MTH8302_Leçon0.ipynb # Numpy NumPy est une bibliothèque numérique pour le langage Python. Elle est conçue pour effectuer des opérations numériques sur les tableaux multidimensionnels. Nous allons l'uiliser dans notre cours """ import numpy as np """# Exemple d'Opérations Vectorielles""" # Définir les vecteurs u = np.array([1, 2]) v = np.array([3, 4]) # Addition print("Addition de vecteurs :", u + v) # Multiplication scalaire alpha = 2 print("Multiplication scalaire :", alpha * u) # Produit scalaire print("Produit scalaire :", np.dot(u, v)) """# Exemple de Produit Extérieur (Outer Product) """ # Définir les vecteurs x = np.array([2, 3, 4]) # Vecteur x ones = np.ones(5) # Vecteur de 1 avec 5 éléments # Calcul du produit extérieur outer_product = np.outer(x, ones) # Affichage des résultats print("Vecteur x :", x) print("Vecteur de 1 :", ones) print("Produit ext´erieur :") print(outer_product) """# `np.arange` et `np.reshape`""" np.arange(1,10,1).reshape((3,3)) """# Exemple de Produit Matrice-Vecteur""" # Définir la matrice A et le vecteur x A = np.arange(1,10,1).reshape((3,3)) x = np.array([1, 0, -1]) # Calculer le produit matrice-vecteur y = np.dot(A, x) # Afficher les résultats print("Matrice A :\n", A) print("Vecteur x :", x) print("Produit Matrice-Vecteur (y = A x) :", y) """# Normes $\ell_p$ et $\ell_\infty$""" # Définir le vecteur v = np.array([3, 4]) # Calculer les normes euclidean_norm = np.linalg.norm(v, ord=2) manhattan_norm = np.linalg.norm(v, ord=1) infinity_norm = np.linalg.norm(v, ord=np.inf) # Afficher les résultats print("Vecteur:", v) print("Norme Euclidienne:", euclidean_norm) print("Norme Manhattan:", manhattan_norm) print("Norme infinie:", infinity_norm) """# Visualization des Normes $\ell_1, \ell_2$ et $l_∞$ """ import matplotlib.pyplot as plt import seaborn as sns sns.set() # Fonction pour générer la boule unité pour les normes l1, l2 et l_infini def generate_unit_ball(p, num_points=1000): if p == 1: # Forme en losange pour la norme l1 x = np.linspace(-1, 1, num_points) y1 = 1 - np.abs(x) # Limite supérieure y2 = -1 + np.abs(x) # Limite inférieure return np.concatenate([x, x[::-1]]), np.concatenate([y1, y2[::-1]]) elif p == 2: # Cercle pour la norme l2 theta = np.linspace(0, 2 * np.pi, num_points) x = np.cos(theta) y = np.sin(theta) return x, y elif p == np.inf: # Carré pour la norme l_infini x = np.array([1, 1, -1, -1, 1]) y = np.array([1, -1, -1, 1, 1]) return x, y else: raise ValueError( "Seules les normes l1, l2 et l_infini sont prises en charge." ) # Tracer les boules unités fig, axs = plt.subplots(1, 3, figsize=(15, 5)) # Tracé pour la norme l1 x, y = generate_unit_ball(1) axs[0].plot(x, y, color='red', label=r'$\ell_1$') axs[0].set_title(r'Norme $\ell_1$ (Losange)') axs[0].set_aspect('equal') axs[0].grid(color='gray', linestyle='--', linewidth=0.5) # Tracé pour la norme l2 x, y = generate_unit_ball(2) axs[1].plot(x, y, color='green', label=r'$\ell_2$') axs[1].set_title(r'Norme $\ell_2$ (Cercle)') axs[1].set_aspect('equal') axs[1].grid(color='gray', linestyle='--', linewidth=0.5) # Tracé pour la norme l_infini x, y = generate_unit_ball(np.inf) axs[2].plot(x, y, color='blue', label=r'$\ell_\infty$') axs[2].set_title(r'Norme $\ell_\infty$ (Carré)') axs[2].set_aspect('equal') axs[2].grid(color='gray', linestyle='--', linewidth=0.5) # Ajuster les limites et étiquettes pour tous les sous-graphiques for ax in axs: ax.set_xlim([-1.5, 1.5]) ax.set_ylim([-1.5, 1.5]) ax.axhline(0, color='black', linewidth=0.5) ax.axvline(0, color='black', linewidth=0.5) ax.legend() plt.tight_layout() plt.show() """# Exemple d'Addition Matricielle""" # Définir les matrices A = np.array([[1, 2, 3], [4, 5, 6]]) B = np.array([[7, 8, 9], [10, 11, 12]]) # Addition de matrices C = A + B print("Addition de matrices:\n", C) """# Exemple de Multiplication scalaire d'une Matrice""" # Définir la matrice A = np.array([[1, 2, 3], [4, 5, 6]]) # Scalaire alpha = 3 # Multiplication scalaire B = alpha * A print("Multiplication scalaire de la matrice:\n", B) """# Exemple de Multiplication Matricielle""" # Définir les matrices A et B A = np.arange(1,7).reshape((3,2)) B = np.arange(7,11).reshape((2,2)) # Calculer le produit matrice-matrice C = np.dot(A, B) # Afficher les r´esultats print("Matrice A :\n", A) print("Matrice B :\n", B) print("Produit Matrice-Matrice (C = A x B) :\n", C) """# Comment définir une Matrice d'Identité et une Matrice Diagonale""" import numpy as np # Matrice Identité I = np.eye(3) print("Matrice Identit´e :\n", I) # Matrice Diagonale d = [3, 5, 7] D = np.diag(d) print("Matrice Diagonale :\n", D) """# Obtenir la Transposée d'une Matrice""" # Définir la matrice A = np.array([[1, 2, 3], [4, 5, 6]]) # Calculer la transpos´ee A_transpose = A.T print("Matrice originale :\n", A) print("Transpos´ee de la matrice :\n", A_transpose) """# Obtenir la Trace d'une Matrice""" # Définir la matrice A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # Calculer la trace trace_A = np.trace(A) # Afficher le résultat print("La trace de la matrice A est :", trace_A) """# Matrice Symétrique""" # Définir une matrice sym´etrique A = np.array([[1, 2, 3], [2, 4, 5], [3, 5, 6]]) # Vérifier si la matrice est sym´etrique is_symmetric = np.allclose(A, A.T) print("Matrice A:\n", A) print("A est-elle symétrique?:", is_symmetric) """# Obtenir le Déterminant d'une Matrice""" # Matrice 2x2 A = np.array([[4, 3], [6, 3]]) # Calcul du déterminant det_A = np.linalg.det(A) print(f"Déterminant de A : {det_A:.2f}") # Matrice 3x3 B = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # Calcul du déterminant det_B = np.linalg.det(B) print(f"Déterminant de B : {det_B:.2f}") # Définir une matrice 2x2 A = np.array([[2, 1], [1, 2]]) # Définir le carré unité unit_square = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]) # Fermer le carré pour le tracé # Appliquer la transformation transformed_square = unit_square @ A.T # Calculer le déterminant det_A = np.linalg.det(A) # Créer le graphique fig, ax = plt.subplots(figsize=(8, 8)) # Tracer le carré unité original ax.plot(unit_square[:, 0], unit_square[:, 1], 'b-', label='Carré unité') ax.fill(unit_square[:, 0], unit_square[:, 1], color='blue', alpha=0.2) # Tracer le parallélogramme transformé ax.plot(transformed_square[:, 0], transformed_square[:, 1], 'r-', label='Parallélogramme transformé') ax.fill(transformed_square[:, 0], transformed_square[:, 1], color='red', alpha=0.2) # Ajouter les vecteurs (colonnes de A) pour plus de clarté origin = np.array([0, 0]) ax.quiver(*origin, *A[:, 0], angles='xy', scale_units='xy', scale=1, color='green', label='Colonne 1 de A') ax.quiver(*origin, *A[:, 1], angles='xy', scale_units='xy', scale=1, color='purple', label='Colonne 2 de A') # Mise en forme ax.set_xlim(-1, 4) ax.set_ylim(-1, 4) ax.axhline(0, color='black', linewidth=0.5) ax.axvline(0, color='black', linewidth=0.5) ax.grid(color='gray', linestyle='--', linewidth=0.5) ax.set_aspect('equal', 'box') ax.set_title(f"Transformation par la Matrice A\nDéterminant = {det_A:.2f}") ax.legend() # Afficher le graphique plt.show() # Définir une matrice 2x2 A = np.array([[-2, 1], [1, 2]]) # Définir le carré unité unit_square = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]) # Fermer le carré pour le tracé # Appliquer la transformation transformed_square = unit_square @ A.T # Calculer le déterminant det_A = np.linalg.det(A) # Créer le graphique fig, ax = plt.subplots(figsize=(8, 8)) # Tracer le carré unité original ax.plot(unit_square[:, 0], unit_square[:, 1], 'b-', label='Carré unité') ax.fill(unit_square[:, 0], unit_square[:, 1], color='blue', alpha=0.2) # Tracer le parallélogramme transformé ax.plot(transformed_square[:, 0], transformed_square[:, 1], 'r-', label='Parallélogramme transformé') ax.fill(transformed_square[:, 0], transformed_square[:, 1], color='red', alpha=0.2) # Ajouter les vecteurs (colonnes de A) pour plus de clarté origin = np.array([0, 0]) ax.quiver(*origin, *A[:, 0], angles='xy', scale_units='xy', scale=1, color='green', label='Colonne 1 de A') ax.quiver(*origin, *A[:, 1], angles='xy', scale_units='xy', scale=1, color='purple', label='Colonne 2 de A') # Mise en forme ax.set_xlim(-3, 2) ax.set_ylim(-1, 4) ax.axhline(0, color='black', linewidth=0.5) ax.axvline(0, color='black', linewidth=0.5) ax.grid(color='gray', linestyle='--', linewidth=0.5) ax.set_aspect('equal', 'box') ax.set_title(f"Transformation par la Matrice A\nDéterminant = {det_A:.2f}") ax.legend() # Afficher le graphique plt.show() # Définir une matrice 2x2 A = np.array([[2, 1], [4, 2]]) # Définir le carré unité unit_square = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]) # Fermer le carré pour le tracé # Appliquer la transformation transformed_square = unit_square @ A.T # Calculer le déterminant det_A = np.linalg.det(A) # Créer le graphique fig, ax = plt.subplots(figsize=(8, 8)) # Tracer le carré unité original ax.plot(unit_square[:, 0], unit_square[:, 1], 'b-', label='Carré unité') ax.fill(unit_square[:, 0], unit_square[:, 1], color='blue', alpha=0.2) # Tracer le parallélogramme transformé ax.plot(transformed_square[:, 0], transformed_square[:, 1], 'r-', label='Parallélogramme transformé') ax.fill(transformed_square[:, 0], transformed_square[:, 1], color='red', alpha=0.2) # Ajouter les vecteurs (colonnes de A) pour plus de clarté origin = np.array([0, 0]) ax.quiver(*origin, *A[:, 0], angles='xy', scale_units='xy', scale=1, color='green', label='Colonne 1 de A') ax.quiver(*origin, *A[:, 1], angles='xy', scale_units='xy', scale=1, color='purple', label='Colonne 2 de A') # Mise en forme ax.set_xlim(-1, 4) ax.set_ylim(-1, 7) ax.axhline(0, color='black', linewidth=0.5) ax.axvline(0, color='black', linewidth=0.5) ax.grid(color='gray', linestyle='--', linewidth=0.5) ax.set_aspect('equal', 'box') ax.set_title(f"Transformation par la Matrice A\nDéterminant = {det_A:.2f}") ax.legend() # Afficher le graphique plt.show() """# Obtenir la Norme de Frobenius d'une Matrice""" # Définir la matrice A = np.array([[1, 2, 3], [4, 5, 6]]) # Calculer la norme de Frobenius frobenius_norm = np.linalg.norm(A, 'fro') # Afficher le résultat print("Matrice A :\n", A) print("Norme de Frobenius : {:.4f}".format(frobenius_norm)) """# Visualisation de Vecteurs Colinéaires dans $\mathbb{R}^2$""" # Visualisation en R^2 pour les vecteurs dépendants def plot_R2_dependent(): # Définir deux vecteurs linéairement dépendants dans R^2 v1 = np.array([2, 3]) v2 = np.array([4, 6]) # v2 est un multiple scalaire de v1 origine = np.array([0, 0]) # Origine fig, ax = plt.subplots(figsize=(6, 6)) ax.quiver(*origine, v2[0], v2[1], angles='xy', scale_units='xy', scale=1, color='b', label=r'$\vec{v}_2$') ax.quiver(*origine, v1[0], v1[1], angles='xy', scale_units='xy', scale=1, color='r', label=r'$\vec{v}_1$') # Définir la grille et les étiquettes ax.set_xlim(-1, 7) ax.set_ylim(-1, 7) ax.axhline(0, color='black', linewidth=0.5) ax.axvline(0, color='black', linewidth=0.5) ax.set_aspect('equal') ax.grid(True, which='both', linestyle='--', linewidth=0.5) ax.set_xlabel('Axe des x') ax.set_ylabel('Axe des y') ax.set_title('Dépendance linéaire dans $R^2$') # Ajouter une légende ax.legend() plt.show() # Appeler la fonction pour générer les visualisations plot_R2_dependent() """# Visualization de vecteurs Indépendants dans $\mathbb{R}^2$""" # Visualisation en R^2 def plot_R2(): # Définir deux vecteurs linéairement indépendants dans R^2 v1 = np.array([1, 2]) v2 = np.array([3, 1]) origine = np.array([0, 0]) # Origine fig, ax = plt.subplots(figsize=(6, 6)) ax.quiver(*origine, v1[0], v1[1], angles='xy', scale_units='xy', scale=1, color='r', label=r'$\vec{v}_1$') ax.quiver(*origine, v2[0], v2[1], angles='xy', scale_units='xy', scale=1, color='b', label=r'$\vec{v}_2$') # Définir la grille et les étiquettes ax.set_xlim(-1, 4) ax.set_ylim(-1, 4) ax.axhline(0, color='black', linewidth=0.5) ax.axvline(0, color='black', linewidth=0.5) ax.set_aspect('equal') ax.grid(True, which='both', linestyle='--', linewidth=0.5) ax.set_xlabel('Axe des x') ax.set_ylabel('Axe des y') ax.set_title('Indépendance linéaire dans $R^2$') # Ajouter une légende ax.legend() plt.show() # Appeler la fonction pour générer les visualisations plot_R2() # Définir une matrice A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # Calculer le rang rang = np.linalg.matrix_rank(A) print(f"Le rang de la matrice est : {rang}") # Vérifier l'indépendance linéaire des colonnes def verifier_independance_lineaire(matrice): rang = np.linalg.matrix_rank(matrice) return rang == min(matrice.shape[0], matrice.shape[1]) independance = verifier_independance_lineaire(A) print(f"Les colonnes sont-elles linéairement indépendantes ? {independance}") independance = verifier_independance_lineaire(A) print(f"Les colonnes sont-elles linéairement indépendantes ? {independance}") # Function to apply an orthogonal transformation def apply_transformation(matrix, points): return np.dot(matrix, points) # Define points for a square (cube in 2D) square = np.array([ [-1, 1, 1, -1, -1], [-1, -1, 1, 1, -1] ]) # Coordinates of the square vertices (closed loop) # Define points for a triangle triangle = np.array([ [0, 1, -1, 0], [1, -1, -1, 1] ]) # Coordinates of the triangle vertices (closed loop) # Define a rotation matrix (45 degrees) theta_rotation = np.pi / 4 rotation_matrix = np.array([ [np.cos(theta_rotation), -np.sin(theta_rotation)], [np.sin(theta_rotation), np.cos(theta_rotation)] ]) # Define a reflection matrix (reflection across the y-axis) reflection_matrix = np.array([ [1, 0], [ 0, -1] ]) # Apply the transformations square_rotated = apply_transformation(rotation_matrix, square) triangle_rotated = apply_transformation(rotation_matrix, triangle) square_reflected = apply_transformation(reflection_matrix, square) triangle_reflected = apply_transformation(reflection_matrix, triangle) # Plot the original, rotated, and reflected shapes plt.figure(figsize=(12, 6)) # Original shapes plt.subplot(1, 3, 1) plt.plot(square[0, :], square[1, :], label="Carré", color="orange") plt.plot(triangle[0, :], triangle[1, :], label="Triangle", color="green") plt.axhline(0, color="black", linewidth=0.5, linestyle="--") plt.axvline(0, color="black", linewidth=0.5, linestyle="--") plt.title("Formes originales") plt.axis("equal") plt.legend() # Rotated shapes plt.subplot(1, 3, 2) plt.plot(square_rotated[0, :], square_rotated[1, :], label="Carré (rotation)", color="orange") plt.plot(triangle_rotated[0, :], triangle_rotated[1, :], label="Triangle (rotation)", color="green") plt.axhline(0, color="black", linewidth=0.5, linestyle="--") plt.axvline(0, color="black", linewidth=0.5, linestyle="--") plt.title("Formes après rotation") plt.axis("equal") plt.legend() # Reflected shapes plt.subplot(1, 3, 3) plt.plot(square_reflected[0, :], square_reflected[1, :], label="Carré (réflexion)", color="orange") plt.plot(triangle_reflected[0, :], triangle_reflected[1, :], label="Triangle (réflexion)", color="green") plt.axhline(0, color="black", linewidth=0.5, linestyle="--") plt.axvline(0, color="black", linewidth=0.5, linestyle="--") plt.title("Formes après réflexion") plt.axis("equal") plt.legend() # plt.suptitle("Interprétation géométrique des matrices orthogonales (Rotation et Réflexion)", fontsize=14) plt.tight_layout() plt.show() # Exemple : Matrice de rotation en 2D theta = np.pi / 4 # Angle de 45 degrés R = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]) # Vérification de l'orthogonalité # R.T @ R est equivalent à np.dot(R.T, R) orthogonal_check = np.allclose(R.T @ R, np.eye(2)) print("Matrice R :") print(R) print(f"La matrice R est-elle orthogonale " f"? {'Oui' if orthogonal_check else 'Non'}") # Norme préservée v = np.array([1, 0]) transformed_v = R @ v original_norm = np.linalg.norm(v) transformed_norm = np.linalg.norm(transformed_v) print(f"Norme du vecteur original : {original_norm:.2f}") print(f"Norme du vecteur transformé : {transformed_norm:.2f}") """# Visualisation des Valeurs et des Vecteurs Propres""" # Définir une matrice 2x2 (exemple) A = np.array([[3, 1], [1, 3]]) # Calculer les valeurs propres et les vecteurs propres eigenvalues, eigenvectors = np.linalg.eig(A) # Générer des points sur un cercle unité theta = np.linspace(0, 2 * np.pi, 100) # Cercle unité sous forme de tableau (2, 100) unit_circle = np.array([np.cos(theta), np.sin(theta)]) # Transformer le cercle unité avec la matrice A transformed_circle = A @ unit_circle # Tracer le cercle unité d'origine plt.figure(figsize=(8, 8)) plt.plot(unit_circle[0], unit_circle[1], label="Cercle Unité (Avant Transformation)", color="blue") # Tracer l'ellipse transformée plt.plot(transformed_circle[0], transformed_circle[1], label="Ellipse Transformée", color="orange") # Tracer les vecteurs propres (mis à l'échelle par leurs valeurs propres) for i in range(len(eigenvalues)): eigenvector = eigenvectors[:, i] eigenvalue = eigenvalues[i] # Mettre les vecteurs propres à l'échelle des valeurs propres scaled_vector = eigenvalue * eigenvector plt.quiver(0, 0, scaled_vector[0], scaled_vector[1], angles='xy', scale_units='xy', scale=1, color='red', label=f"Vecteur Propre {i+1} (λ = {eigenvalue:.2f})") # Ajouter des labels, une légende et une grille plt.axhline(0, color='black', linewidth=0.5) plt.axvline(0, color='black', linewidth=0.5) plt.grid(color='gray', linestyle='--', linewidth=0.5) plt.gca().set_aspect('equal', adjustable='box') plt.legend() plt.title("Interprétation Géométrique des Valeurs et Vecteurs Propres") plt.xlabel("Axe des x") plt.ylabel("Axe des y") plt.show() """# Valeurs Propres et Vecteurs Propres""" import numpy as np from numpy.linalg import eig # Exemple : Définir une matrice A = np.array([[3, 1], [1, 3]]) # Calculer les valeurs propres et les vecteurs propres eigenvalues, eigenvectors = eig(A) print("Matrice A:") print(A) # Valeurs propres print("Valeurs propres:") print(eigenvalues) # Vecteurs propres print("Vecteurs propres:") print(eigenvectors) # Vérification : A * v = λ * v pour chaque vecteur propre for i in range(len(eigenvalues)): v = eigenvectors[:, i] lambda_v = eigenvalues[i] * v Av = np.dot(A, v) print(f"Vérification pour λ = {eigenvalues[i]:.2f}:") print("A * v =", Av) print("λ * v =", lambda_v) print("Égalité :", np.allclose(Av, lambda_v)) """# Formes Quadratiques et Matrices Semi-Définies Positives""" # Définir la matrice A et le vecteur x A = np.array([[2, 1], [1, 3]]) x = np.array([1, 2]) # Calcul de la forme quadratique q = x.T @ A @ x print("Matrice A:") print(A) print("Vecteur x:") print(x) print("Valeur de la forme quadratique q(x):", q) import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D # Fonction pour évaluer la forme quadratique def quadratic_form(A, x, y): return A[0, 0]*x**2 + A[0, 1]*x*y + A[1, 1]*y**2 # Définir les matrices matrices = { "Matrice Semi-Définie Positive (SDP)": np.array([[2, 0], [0, 1]]), "Matrice Indéfinie": np.array([[2, -1.5], [-1.5, -1]]), "Matrice Semi-Définie Négative (SDN)": np.array([[-1, 0], [0, -2]]) } # Créer une grille x = np.linspace(-2, 2, 100) # Valeurs de x y = np.linspace(-2, 2, 100) # Valeurs de y X, Y = np.meshgrid(x, y) # Grille pour les coordonnées # Tracer chaque matrice fig = plt.figure(figsize=(15, 10)) for i, (title, A) in enumerate(matrices.items(), 1): # Calculer les valeurs de la forme quadratique Z = quadratic_form(A, X, Y) # Sous-graphe en 3D ax = fig.add_subplot(1, 3, i, projection='3d') # Surface 3D ax.plot_surface(X, Y, Z, cmap="viridis",edgecolor="k", alpha=0.8) ax.set_title(title) # Titre du sous-graphe ax.set_xlabel("x") # Étiquette pour l'axe x ax.set_ylabel("y") # Étiquette pour l'axe y ax.set_zlabel("q(x, y)") # Étiquette pour l'axe z ax.view_init(elev=30, azim=45) # Angle de vue plt.tight_layout() # Ajuster l'espacement des sous-graphiques plt.show() # Afficher la figure