Travailler avec des systèmes linéaires en Python avec scipy.linalg – Real Python

By | juin 16, 2021

Python pas cher

Algèbre linéaire est largement utilisé dans une variété de sujets, et vous pouvez l'utiliser pour résoudre de nombreux problèmes une fois que vous organisez les informations à l'aide de concepts tels que vecteurs et équations linéaires. En Python, la plupart des routines liées à ce sujet sont implémentées dans scipy.linalg, qui offre des capacités d'algèbre linéaire très rapides.

En particulier, systèmes linéaires jouer un rôle important dans la modélisation d'une variété de problèmes du monde réel, et scipy.linalg fournit des outils pour les étudier et les résoudre de manière efficace.

Débuter avec scipy.linalg

SciPy est une bibliothèque Python open source utilisée pour le calcul scientifique, comprenant plusieurs modules pour des tâches courantes en science et en ingénierie telles que l'algèbre linéaire, l'optimisation, l'intégration, l'interpolation et le traitement du signal. Il fait partie de la pile SciPy, qui comprend plusieurs autres packages pour le calcul scientifique tels que NumPy, Matplotlib, SymPy, IPython et pandas.

L'algèbre linéaire est une branche des mathématiques qui concerne les équations linéaires et leurs représentations à l'aide de vecteurs et de matrices. C'est un sujet fondamental utilisé dans plusieurs domaines de l'ingénierie, et c'est une condition préalable à une compréhension plus approfondie de l'apprentissage automatique.

scipy.linalg inclut plusieurs outils pour travailler avec des problèmes d'algèbre linéaire, y compris des fonctions pour effectuer des calculs matriciels, tels que les déterminants, les inverses, les valeurs propres, les vecteurs propres et la décomposition en valeurs singulières.

Dans ce didacticiel, vous allez utiliser certaines des fonctions de scipy.linalg travailler sur des problèmes pratiques impliquant des systèmes linéaires. Pour utiliser scipy.linalg, vous devez installer et configurer la bibliothèque SciPy, ce que vous pouvez faire en utilisant la distribution Python d'Anaconda et le système de gestion de packages et d'environnements conda.

Pour commencer, créez un environnement conda et activez-le :

$ conda create --name linalg
$ conda activer linalg

Après avoir activé l'environnement conda, votre invite affichera son nom, linalg. Ensuite, vous pouvez installer les packages nécessaires dans l'environnement :

(linal) $ conda installer scipy jupyter

Après avoir exécuté cette commande, le système devrait mettre un certain temps à comprendre les dépendances et à procéder à l'installation.

Si vous préférez suivre l'article en utilisant une distribution Python différente et le pépin gestionnaire de packages, puis développez la section réductible ci-dessous pour voir comment configurer votre environnement.

Tout d'abord, il est recommandé de créer un environnement virtuel dans lequel vous installerez les packages. En supposant que Python soit installé, vous pouvez créer un environnement virtuel nommé linalg:

Après avoir créé l'environnement, vous devez l'activer pour pouvoir utiliser pépin pour installer des packages dans l'environnement. Si vous êtes sous Linux ou macOS, vous pouvez activer l'environnement avec la commande :

$ la source ./linalg/bin/activate

Sous Windows, la commande que vous devez utiliser est légèrement différente :

C :> linalgScriptsactivate.bat

Après avoir activé l'environnement conda, votre invite affichera son nom, linalg. Ensuite, vous pouvez installer les packages nécessaires dans l'environnement en utilisant pépin:

(linal) $ python -m pip installer scipy jupyter

Le système prendra un certain temps pour comprendre les dépendances et procéder à l'installation. Une fois la commande terminée, vous êtes prêt à ouvrir Jupyter et à utiliser scipy.linalg.

Avant d'ouvrir Jupyter Notebook, vous devez enregistrer le conda linalg afin que vous puissiez créer des Notebooks en l'utilisant comme noyau. Pour ce faire, avec le linalg environnement activé, exécutez la commande suivante :

(linal) $ python -m ipykernel install --user --name linalg

Vous pouvez maintenant ouvrir Jupyter Notebook en exécutant la commande suivante :

Une fois Jupyter chargé dans votre navigateur, créez un nouveau bloc-notes en cliquant sur Nouveaulinalg, comme indiqué ci-dessous:

Cahier Jupyter

Dans le Notebook, vous pouvez tester si l'installation a réussi en important le scipy paquet:

Maintenant que vous avez fini de configurer l'environnement, vous verrez comment travailler avec des vecteurs et des matrices en Python, ce qui est fondamental pour utiliser scipy.linalg pour travailler avec des applications d'algèbre linéaire.

Travailler avec des vecteurs et des matrices à l'aide de NumPy

UNE vecteur est une entité mathématique utilisée pour représenter des quantités physiques qui ont à la fois une amplitude et une direction. C'est un outil fondamental pour résoudre les problèmes d'ingénierie et d'apprentissage automatique, tout comme matrices, qui sont utilisés pour représenter les transformations vectorielles, entre autres applications.

NumPy est la bibliothèque la plus utilisée pour travailler avec des matrices et des vecteurs en Python et est utilisée avec scipy.linalg pour travailler avec des applications d'algèbre linéaire. Dans cette section, vous découvrirez les bases de son utilisation pour créer des matrices et des vecteurs et pour effectuer des opérations sur eux.

Pour commencer à travailler avec des matrices et des vecteurs, la première chose que vous devez faire dans votre Jupyter Notebook est d'importer numpy. La façon habituelle de le faire est d'utiliser l'alias np:

>>>

Dans [2]: importer numpy comme np

Pour représenter des matrices et des vecteurs, NumPy utilise un type spécial appelé ndarray.

Pour créer un ndarray objet, vous pouvez utiliser np.array(), qui attend un objet de type tableau tel qu'une liste ou une liste imbriquée.

Par exemple, imaginez que vous deviez créer la matrice suivante :

Matrice à représenter à l'aide de NumPy

Pour le créer avec NumPy, vous pouvez utiliser np.array(), fournissant une liste imbriquée contenant les éléments de chaque ligne de la matrice :

>>>

Dans [3]: UNE = np.déployer([[[[[[[[1, 2], [[[[3, 4], [[[[5, 6]])
            ... : UNE
En dehors[3]:
déployer([[1, 2],
       [3, 4],
       [5, 6]])

Comme vous pouvez le remarquer, NumPy fournit une représentation visuelle de la matrice, dans laquelle vous pouvez identifier ses colonnes et ses lignes.

Il est à noter que les éléments d'un tableau NumPy doivent être du même type. Vous pouvez vérifier le type d'un tableau NumPy en utilisant .dtype:

>>>

Dans [4]: UNE.dtype
En dehors[4]:
dtype('int64')

Comme tous les éléments de UNE sont des entiers, le tableau a été créé avec le type int64. Si l'un des éléments est un flottant, alors le tableau sera créé avec le type float64:

>>>

Dans [5]: UNE = np.déployer([[[[[[[[1,0, 2], [[[[3, 4], [[[[5, 6]])
            ... : UNE
En dehors[5]:
déployer([[1., 2.],
       [3., 4.],
       [5., 6.]])

Dans [6]: UNE.dtype
En dehors[6]:
dtype('float64')

Pour vérifier les dimensions d'un ndarray objet, vous pouvez utiliser .façonner. Par exemple, pour vérifier les dimensions de UNE, vous pouvez utiliser Une forme:

>>>

Dans [7]: UNE.façonner
En dehors[7]:
(3, 2)

Comme prévu, les dimensions du UNE matrice sont 3 × 2 puisque UNE comporte trois lignes et deux colonnes.

Lorsque vous travaillez avec des problèmes impliquant des matrices, vous aurez souvent besoin d'utiliser l'opération de transposition, qui permute les colonnes et les lignes d'une matrice.

Pour transposer un vecteur ou une matrice représenté par un ndarray objet, vous pouvez utiliser .transposer() ou alors .T. Par exemple, vous pouvez obtenir la transposition de UNE avec À:

>>>

Dans [8]: UNE.T
En dehors[8]:
déployer([[1., 3., 5.],
       [2., 4., 6.]])

Avec la transposition, les colonnes de UNE devenir les rangées de À et les lignes deviennent les colonnes.

Pour créer un vecteur, vous pouvez utiliser np.array(), fournissant une liste avec les éléments du vecteur :

>>>

Dans [9]: v = np.déployer([[[[1, 2, 3])
            ... : v
En dehors[9]:
déployer([1, 2, 3])

Pour vérifier les dimensions du vecteur, vous utilisez .façonner comme tu l'as fait avant :

>>>

Dans [10]: v.façonner
En dehors[10]:
(3,)

Notez que la forme de ce vecteur est (3,) et pas (3, 1) ou alors (1, 3). Il s'agit d'une fonctionnalité NumPy qui est pertinente pour ceux qui sont habitués à travailler avec MATLAB. Dans NumPy, il est possible de créer des tableaux à une dimension tels que v, ce qui peut poser des problèmes lors de l'exécution d'opérations entre des matrices et des vecteurs. Par exemple, l'opération de transposition n'a aucun effet sur les tableaux à une dimension.

Chaque fois que vous fournissez un argument de type tableau à une dimension à np.array(), le tableau résultant sera un tableau à une dimension. Pour créer un tableau à deux dimensions, vous devez fournir un argument de type tableau à deux dimensions, tel qu'une liste imbriquée :

>>>

Dans [11]: v = np.déployer([[[[[[[[1, 2, 3]])
            ... : v.façonner
En dehors[11]:
(1, 3)

Dans l'exemple ci-dessus, les dimensions de v sont 1 × 3, qui correspond aux dimensions d'un vecteur ligne à deux dimensions. Pour créer un vecteur colonne, vous pouvez utiliser une liste imbriquée :

>>>

Dans [12]: v = np.déployer([[[[[[[[1], [[[[2], [[[[3]])
            ... : v.façonner
En dehors[12]:
(3, 1)

Dans ce cas, les dimensions de v sont 3 × 1, qui correspond aux dimensions d'un vecteur colonne à deux dimensions.

L'utilisation de listes imbriquées pour créer des vecteurs peut être laborieuse, en particulier pour les vecteurs colonnes, qui sont les plus utilisés. Comme alternative, vous pouvez créer un vecteur unidimensionnel, fournissant une liste plate à np.array, et utilise .remodeler() pour changer les dimensions du ndarray objet:

>>>

Dans [13]: v = np.déployer([[[[1, 2, 3]).remodeler(3, 1)
            ... : v.façonner
En dehors[13]:
(3, 1)

Dans l'exemple ci-dessus, vous utilisez .remodeler() pour obtenir un vecteur colonne de forme (3, 1) à partir d'un vecteur unidimensionnel de forme (3,). Cela vaut la peine de mentionner que .remodeler() s'attend à ce que le nombre d'éléments du nouveau tableau soit compatible avec le nombre d'éléments du tableau d'origine. En d'autres termes, le nombre d'éléments du tableau avec la nouvelle forme doit être égal au nombre d'éléments du tableau d'origine.

Dans cet exemple, vous pouvez également utiliser .remodeler() sans définir explicitement le nombre de lignes du tableau :

>>>

Dans [14]: v = np.déployer([[[[1, 2, 3]).remodeler(-1, 1)
            ... : v.façonner
En dehors[14]:
(3, 1)

Ici le -1 vous fournissez comme argument à .remodeler() représente le nombre de lignes nécessaires pour que le nouveau tableau n'ait qu'une seule colonne, comme spécifié par le deuxième argument. Dans ce cas, comme le tableau d'origine a trois éléments, le nombre de lignes du nouveau tableau sera 3.

Dans les applications pratiques, vous devez souvent créer des matrices de zéros, de uns ou d'éléments aléatoires. Pour cela, NumPy fournit quelques fonctions de commodité, que vous verrez ensuite.

Utilisation de fonctions de commodité pour créer des tableaux

NumPy fournit également des fonctions pratiques pour créer des tableaux. Par exemple, pour créer un tableau rempli de zéros, vous pouvez utiliser np.zéros():

>>>

Dans [15]: UNE = np.zéros((3, 2))
            ... : UNE
En dehors[15]:
déployer([[0., 0.],
       [0., 0.],
       [0., 0.]])

Comme premier argument, np.zéros() attend un tuple indiquant la forme du tableau que vous souhaitez créer, et il renvoie un tableau du type float64.

De même, pour créer des tableaux remplis de uns, vous pouvez utiliser np.ones():

>>>

Dans [16]: UNE = np.ceux((2, 3))
            ... : UNE
En dehors[16]:
déployer([[1., 1., 1.],
       [1., 1., 1.]])

Cela vaut la peine de noter que np.ones() renvoie également un tableau du type float64.

Pour créer des tableaux avec des éléments aléatoires, vous pouvez utiliser np.random.rand():

>>>

Dans [17]: UNE = np.Aléatoire.rand(3, 2)
            ... : UNE
En dehors[17]:
déployer([[0.8206045 , 0.54470809],
       [0.9490381 , 0.05677859],
       [0.71148476, 0.4709059 ]])

np.random.rand() renvoie un tableau avec des éléments aléatoires de 0 à 1, tiré d'une distribution uniforme. Notez que, contrairement à np.zéros() et np.ones(), np.random.rand() n'attend pas un tuple comme argument.

De même, pour obtenir un tableau avec des éléments aléatoires tirés d'une distribution normale avec une moyenne nulle et une variance unitaire, vous pouvez utiliser np.random.randn():

>>>

Dans [18]: UNE = np.Aléatoire.randn(3, 2)
            ... : UNE
En dehors[18]:
déployer([[-1.20019512, -1.78337814],
       [-0.22135221, -0.38805899],
       [ 0.17620202, -2.05176764]])

Maintenant que vous avez créé des tableaux, vous allez voir comment effectuer des opérations avec eux.

Exécution d'opérations sur les tableaux NumPy

Les opérations Python habituelles utilisant l'addition (+), soustraction (-), multiplier (*), division (/) et l'exposant (**) sur les tableaux sont toujours exécutés élément par élément. Si l'un des opérandes est un scalaire, alors l'opération sera effectuée entre le scalaire et chaque élément du tableau.

Par exemple, pour créer une matrice remplie d'éléments égaux à dix, vous pouvez utiliser np.ones() et multipliez la sortie par dix utilisant *:

>>>

Dans [19]: UNE = dix * np.ceux((2, 2))
            ... : UNE
En dehors[19]:
déployer([[10., 10.],
       [10., 10.]])

Si les deux opérandes sont des tableaux de même forme, alors l'opération sera effectuée entre les éléments correspondants des tableaux :

>>>

Dans [20]: UNE = dix * np.ceux((2, 2))
            ... : B = np.déployer([[[[[[[[2, 2], [[[[5, 5]])
            ... : C = UNE * B
            ... : C
En dehors[20]:
déployer([[20., 20.],
       [50., 50.]])

Ici, vous multipliez chaque élément de la matrice UNE par l'élément de matrice correspondant B.

Pour effectuer une multiplication matricielle selon les règles de l'algèbre linéaire, vous pouvez utiliser np.dot():

>>>

Dans [21]: UNE = np.déployer([[[[[[[[1, 2], [[[[3, 4]])
            ... : v = np.déployer([[[[[[[[5], [[[[6]])
            ... : X = np.point(UNE, v)
            ... : X
En dehors[21]:
déployer([[[[[17],
       [39]])

Ici, vous multipliez une matrice 2 × 2 nommée UNE par un vecteur 2 × 1 nommé v.

Vous pouvez obtenir le même résultat en utilisant le @ opérateur, qui est pris en charge à la fois par NumPy et Python natif à partir de PEP 465 et Python 3.5 :

>>>

Dans [22]: UNE = np.déployer([[[[[[[[1, 2], [[[[3, 4]])
            ... : v = np.déployer([[[[[[[[5], [[[[6]])
            ... : X = UNE @ v
            ... : X
En dehors[22]:
déployer([[[[[17],
       [39]])

Outre les opérations de base pour travailler avec des matrices et des vecteurs, NumPy fournit également des fonctions spécifiques pour travailler avec l'algèbre linéaire dans numpy.linalg. Cependant, pour ces applications, scipy.linalg présente certains avantages, comme vous le verrez par la suite.

Comparant scipy.linalg Avec numpy.linalg

NumPy inclut des outils pour travailler avec des applications d'algèbre linéaire dans le numpy.linalg module. Cependant, à moins que vous ne souhaitiez pas ajouter SciPy en tant que dépendance à votre projet, il est généralement préférable d'utiliser scipy.linalg Pour les raisons suivantes:

  • Comme expliqué dans la documentation officielle, scipy.linalg contient toutes les fonctions de numpy.linalg plus quelques fonctions avancées supplémentaires non incluses dans numpy.linalg.

  • scipy.linalg est toujours compilé avec le support de BLAS et LAPACK, qui sont des bibliothèques comprenant des routines pour effectuer des opérations numériques de manière optimisée. Pour numpy.linalg, l'utilisation de BLAS et LAPACK est facultative. Ainsi, selon la façon dont vous installez NumPy, scipy.linalg les fonctions peuvent être plus rapides que celles de numpy.linalg.

En conclusion, étant donné que les applications scientifiques et techniques n'ont généralement pas de restrictions concernant les dépendances, c'est généralement une bonne idée d'installer SciPy et d'utiliser scipy.linalg à la place de numpy.linalg.

Dans la section suivante, vous allez utiliser scipy.linalg outils pour travailler avec des systèmes linéaires. Vous commencerez par passer en revue les bases avec un exemple simple, puis vous appliquerez les concepts à un problème pratique.

Utilisant scipy.linalg.solve() pour résoudre des systèmes linéaires

Les systèmes linéaires peuvent être un outil utile pour trouver la solution à plusieurs problèmes pratiques et importants, y compris les problèmes liés à la circulation des véhicules, à l'équilibrage des équations chimiques, aux circuits électriques et à l'interpolation polynomiale.

Dans cette section, vous apprendrez à utiliser scipy.linalg.solve() pour résoudre des systèmes linéaires. Mais avant de mettre la main sur le code, il est important de comprendre les bases.

Apprendre à connaître les systèmes linéaires

UNE système linéaire ou, plus précisément, un système d'équations linéaires, est un ensemble d'équations se rapportant linéairement à un ensemble de variables. Voici un exemple de système linéaire relatif aux variables X, X, et X:

Exemple de système linéaire

Ici, vous avez trois équations impliquant trois variables. Afin d'avoir un linéaire système, les valeurs KKet bbdoit être des constantes.

Lorsqu'il n'y a que deux ou trois équations et variables, il est possible d'effectuer les calculs manuellement, de combiner les équations et de trouver les valeurs des variables. Cependant, avec quatre variables ou plus, la résolution manuelle d'un système linéaire prend un temps considérable et il est courant de faire des erreurs.

Les applications pratiques impliquent généralement un grand nombre de variables, ce qui rend impossible la résolution manuelle de systèmes linéaires. Heureusement, il existe des outils qui peuvent effectuer ce travail difficile, tels que scipy.linalg.solve().

Utilisant scipy.linalg.solve()

SciPy fournit scipy.linalg.solve() pour résoudre des systèmes linéaires rapidement et de manière fiable. Pour voir comment cela fonctionne, considérons le système suivant :

Système linéaire

Pour utiliser scipy.linalg.solve(), vous devez d'abord écrire le système linéaire sous la forme d'un produit matriciel, comme dans l'équation suivante :

Système linéaire exprimé à l'aide de matrices et de vecteurs

Notez que vous arriverez aux équations originales du système après avoir calculé le produit matriciel. Les entrées scipy.linalg.solve() s'attend à résoudre le système sont la matrice UNE et le vecteur b, que vous pouvez définir à l'aide des tableaux NumPy. De cette façon, vous pouvez résoudre le système en utilisant le code suivant :

>>>

    1Dans [1]: importer numpy comme np
    2            ... : de scipy.linalg importer résoudre
    3
    4Dans [2]: UNE = np.déployer(
    5            ... :    [[[[
    6            ... :        [[[[3, 2],
    7            ... :        [[[[2, -1],
    8            ... :    ]
    9            ... : )
dix
11Dans [3]: b = np.déployer([[[[12, 1]).remodeler((2, 1))
12
13Dans [4]: X = résoudre(UNE, b)
14            ... : X
15En dehors[4]:
16déployer([[2.],
17       [3.]])

Voici une ventilation de ce qui se passe:

  • Lignes 1 et 2 importer NumPy en tant que np de même que résoudre() de scipy.linalg.
  • Lignes 4 à 9 créer la matrice des coefficients à l'aide d'un tableau NumPy appelé UNE.
  • Ligne 11 crée le vecteur de termes indépendants à l'aide d'un tableau NumPy appelé b. Pour en faire un vecteur colonne avec deux lignes, vous utilisez .remodeler((2, 1)).
  • Lignes 13 et 14 appel résoudre() pour résoudre le système linéaire caractérisé par UNE et b, avec le résultat stocké dans X, qui est imprimé. Noter que résoudre() renvoie la solution avec des composants à virgule flottante, même si tous les éléments des tableaux d'origine sont des entiers.

Si vous remplacez X=2 et X₂=3 dans les équations originales, alors vous pouvez vérifier que c'est la solution du système.

Maintenant que vous connaissez les bases de l'utilisation scipy.linalg.solve(), il est temps de voir une application pratique des systèmes linéaires.

Résoudre un problème pratique : élaborer un plan de repas

Un type de problème généralement résolu avec les systèmes linéaires est celui où vous devez trouver les proportions des composants nécessaires pour obtenir un certain mélange. Ci-dessous, vous allez utiliser cette idée pour élaborer un plan de repas, en mélangeant différents aliments afin d'obtenir une alimentation équilibrée.

Pour cela, considérez qu'une alimentation équilibrée doit comprendre les éléments suivants :

  • 170 unités de vitamine A
  • 180 unités de vitamine B
  • 140 unités de vitamine C
  • 180 unités de vitamine D
  • 350 unités de vitamine E

Votre tâche est de trouver les quantités de chaque aliment différent afin d'obtenir la quantité spécifiée de vitamines. Dans le tableau suivant, vous avez les résultats de l'analyse d'un gramme de chaque aliment en termes d'unités de chaque vitamine :

Aliments Vitamine A Vitamine B Vitamine C Vitamine D Vitamine E
#1 1 dix 1 2 2
#2 9 1 0 1 1
#3 2 2 5 1 2
#4 1 1 1 2 13
#5 1 1 1 9 2

En désignant l'aliment 1 comme Xet ainsi de suite, et vu que tu vas mixer X₁ unités de nourriture 1, X₂ unités de nourriture 2, et ainsi de suite, vous pouvez écrire une expression pour la quantité de vitamine A que vous obtiendriez dans la combinaison. Considérant qu'une alimentation équilibrée doit inclure 170 unités de vitamine A, vous pouvez utiliser les données de la colonne Vitamine A pour écrire l'équation suivante :

Équation pour la vitamine A

En répétant la même procédure pour les vitamines B, C, D et E, vous arrivez au système linéaire suivant :

Système linéaire pour toutes les vitamines

Utiliser scipy.linalg.solve(), il faut obtenir la matrice des coefficients UNE et le vecteur de termes indépendants b, qui sont donnés par :

Système linéaire pour toutes les vitamines utilisant des matrices et des vecteurs

Il ne vous reste plus qu'à utiliser scipy.linalg.solve() pour connaître les quantités X, …, X:

>>>

Dans [1]: importer numpy comme np
            ... : de scipy.linalg importer résoudre

Dans [2]: UNE = np.déployer(
            ... :     [[[[
            ... :         [[[[1, 9, 2, 1, 1],
            ... :         [[[[dix, 1, 2, 1, 1],
            ... :         [[[[1, 0, 5, 1, 1],
            ... :         [[[[2, 1, 1, 2, 9],
            ... :         [[[[2, 1, 2, 13, 2],
            ... :     ]
            ... : )

Dans [3]: b = np.déployer([[[[170, 180, 140, 180, 350]).remodeler((5, 1))

Dans [4]: X = résoudre(UNE, b)
            ... : X
En dehors[4]:
déployer([[10.],
       [10.],
       [20.],
       [20.],
       [10.]])

Cela indique qu'une alimentation équilibrée doit inclure dix unités de nourriture 1, dix unités de nourriture 2, 20 unités de nourriture 3, 20 unités de nourriture 4, et dix unités de nourriture 5.

Conclusion

Toutes nos félicitations! Vous avez appris à utiliser certains concepts d'algèbre linéaire et à utiliser scipy.linalg pour résoudre des problèmes impliquant des systèmes linéaires. Vous avez vu que les vecteurs et les matrices sont utiles pour représenter des données et qu'en utilisant des concepts d'algèbre linéaire, vous pouvez modéliser des problèmes pratiques et les résoudre de manière efficace.

Dans ce tutoriel, vous avez appris à :

  • Appliquer notions d'algèbre linéaire à des problèmes pratiques en utilisant scipy.linalg
  • Travailler avec vecteurs et matrices en utilisant Python et NumPy
  • Modéliser des problèmes pratiques en utilisant systèmes linéaires
  • Résoudre des systèmes linéaires en utilisant scipy.linalg

L'algèbre linéaire est un sujet très vaste. Pour plus d'informations sur d'autres applications d'algèbre linéaire, consultez les ressources suivantes :

Continuez à étudier et n'hésitez pas à laisser vos questions ou commentaires ci-dessous !

[ad_2]