Rappelons que dorénavant les programmes commencent tous par :
import numpy as np
import matplotlib.pyplot as plt
L'algèbre linéaire consiste essentiellement en la manipulation de matrices.
Modules à utiliser.
Deux modules fournissent les fonctions utiles pour l'algèbre linéaire : codice_1 et codice_2. Le module SciPy est plus complet et est parfois plus rapide que le module NumPy. Nous considérons donc que nous utilisons le premier et ajoutons en en-tête :
from scipy import linalg
Norme et déterminant.
La norme « classique » s'obtient par codice_3 ; pour les vecteurs, il s'agit de la norme d'ordre 2 (L2) et pour les matrice, la norme de Frobénius
A = np.array(1,2],[3,4)
linalg.norm(A) # 5.4772...
Pour les vecteurs, on peut utiliser une norme d'ordre "n" quelconque, formula_1 avec
linalg.norm(x, n)
Si "n" prend pour valeur codice_4, cela renvoie max(|"xi"|) ; pour valeur codice_5, min(|"xi"|).
Pour une matrice, les valeurs d'ordre possibles sont codice_6, codice_7, codice_8 et codice_9 (pour Frobenius, valeur par défaut).
Le déterminant s'obtient avec
linalg.det(A)
Résolution d'un système linéaire.
Un système linéaire d'équations peut se représenter par une équation matricielle :
avec
Si le système possède une solution, alors la matrice A est inversible et le résultat peut s'obtenir par :
En Python, cela peut s'obtenir de deux manières :
la seconde méthode étant plus rapide.
Par exemple, pour résoudre le système
A = np.array(1, 2], [3, 4)
b = np.array(5], [6)
X = linalg.solve(A, b)
print(X)
Notes et références.
Régression et optimisation < ↑ > Calcul différentiel et intégral

Python pour le calcul scientifique/Résolution d'équations

Rappelons que dorénavant les programmes commencent tous par :
import numpy as np
import matplotlib.pyplot as plt
Système d'équations linéaires.
Le sujet a été abordé dans le chapitre concernant l'algèbre linéaire.
Équation polynomiale.
La résolution d'une équation polynomiale consiste à trouver les racines de son polynôme. Par exemple, pour résoudre l'équation
nous pouvons utiliser :
import numpy.polynomial.polynomial as nppol
X = nppol.polyroots([5, 3, 1]) # [-1.5-1.6583124j -1.5+1.6583124j]
Équation différentielle.
Le sujet est abordé dans le chapitre sur le calcul différentiel.
Équation quelconque.
Une équation peut s'écrire de manière générale 
ce qui revient à résoudre
Le module codice_1 propose la fonction codice_2 pour cela.
Par exemple, nous cherchons ci-dessous à résoudre "x"² + 5⋅sin "x" = 2
import numpy as np
import matplotlib.pyplot as plt
from scipy import optimize as opt
def f(x):
 fonction présentant au moins un zéro
 return x*x + 5*np.sin(x)
def residu(x, y):
 return f(x) - y
x = np.linspace(-4, 4, 40)
y = f(x)
ycible = 2
x0 = 0 # point de départ
minimum = opt.root(residu, x0, args=(ycible))
xopt = minimum.x[0]
yopt = f(xopt)
print(f"La valeur y = {round(yopt, 2)} est atteinte pour x = {round(xopt, 2)}")
plt.plot(x, y)
plt.plot((x[0], x[-1]), (ycible, ycible), "--k", linewidth=0.5)
plt.plot(xopt, yopt, "+k")
Le graphique nous montre qu'il existe une autre solution ("x" = –2,35). Nous pouvons trouver la trouver avec un point de départ différent, par exemple codice_3.
Cette méthode marche aussi pour des systèmes d'équations, en recherchant le vecteur nul. Considérons par exemple une poutre de section rectangulaire L × "l", par exemple une planche de largeur L et de hauteur "l". Sa raideur dépend du matériau dont elle est faite (bois, acier, aluminium…) mais aussi de sa forme ; la contribution de la forme à la raideur est exprimée par le moment quadratique I, exprimé en mm⁴ (si L et "l" sont en mm). Mise à plat, le moment quadratique vaut
Mise à chant (c'est-à-dire posée sur la tranche), il vaut :
Nous cherchons les dimensions L et "l" telles que I1 = et I2 = . Pour cela, nous définissons le vecteur d'état codice_4 et la fonction moment quadratique codice_5. Nous partons de dimensions "a priori" L = "l" = . Nous cherchons donc à résoudre le système
par l'équation vectorielle
import numpy as np
from scipy import optimize as opt
def I(X):
 L = X[0]
 LLL = L*L*L # L³
 l = X[1]
 lll = l*l*l # l³
 return (1/12)*np.array([L*lll, LLL*l]) # ([I1, I2]) en mm⁴
def residu(X, Y):
 return I(X)-Y
ycible = np.array([200000, 700000])
x0 = np.array([50, 50])
minimum = opt.root(residu, x0, args=(ycible))
print("Poutre\n")
print(minimum)
print("\n")
Xopt = minimum.x
Lopt = Xopt[0]
lopt = Xopt[1]
print(f"Section : ({Lopt.:3f}, {lopt:.3f}) mm") # (62.962, 33.655) mm
print(f"Moments quadratiques : ({I(Xopt)}) mm⁴") # ([199999.99999985 700000.00000009]) mm⁴
Il nous faut donc une planche de dimensions approximatives 63 × 34 mm².
Notes et références.
Calcul différentiel et intégral < ↑ > Calcul symbolique

Mesure en cuisine
Mathc initiation/a00
Vous trouverez dans cette section une suite de fichiers h. Installez ces fichiers dans votre répertoire de travail. Ils seront appelés par le fichier c de chaque exemple si nécessaire. 
L'étude de ce chapitre peut ce faire à l'aide de cette [Playlist]..

Auto-éditer un wikilivre/Annexer (Version imprimable/Annexe orig