Les bibliothèques :
import numpy as np
import sympy as sp
import [Link] as plt //pour les graphs
from [Link] import Polynomial //pour les polynomes
**********************************************************************************
Intervalle entre 1 et n
[Link] (1,n)
Longueur de x
Len(x)
Déclaration d’une fonction f
F=lambda x :f(2*x)
Nom_fonction= lambda x : expression de fonction
**********************************************************************************
Déclaration d’un tableau
A=[Link]([1,2,3,6,5,])
Déclaration d’un vecteur
A=[Link]([1],[2],[3])
Déclaration d’une matrice
A=[Link] ([[4,2,3],[5,8,9],[5,5,6]]) (ligne)
Copier une matrice dans une autre
B=[Link]()
Créer une matrice avec Input comme diagonale
M=[Link]([Link](A))
Extraire la diagonale d’une matrice
[Link](M)
Créer une matrice à zero
Ab=[Link]((ligne,colone)) ex : ab=[Link]((3,2)) 3 lignes et 2 colones
L’inverse d’une matrice
[Link](M)
Transposé d’une matrice
A.T
Nombre de ligne
[Link](A)[0]
Nombre de colonnes
[Link](A)[1]
Somme éléments d’une matrice
[Link](A)
Produit de deux matrices
[Link](M)
Somme deux matrices
A+M
Calculer la norme d’une matrice
[Link](A-B,1) 1=l’ordre dima 1
Triangulaire inféireur de matrice
[Link](A)
Triangulaire supéireur de matrice
[Link](A)
Calculer le det d’une matrice
[Link](A)
**********************************************************************************
Expression d’Intégral :
x=[Link](‘x’)
I=[Link] (fonction,(x,borne1,borne2)).evalf()
//([Link] et non pas [Link]) et [Link]
Calcul d’intégral :
[Link]([Link](-x),(x,0,1)).evalf()
avec : 0 et 1 sont les bornes d’intervalle
Ecriture exponentielle :
[Link] (puissance) ==== [Link](-1) = 𝑒−1
Valeur absolus
[Link] (v) === [Link](-5)=5
Calculer la dérivée de f :
[Link](f(x),x )
Ex : df=[Link](x,[Link](f(x),x))
Création d’une liste
t=[Link](-2*[Link],2*[Link],10**3)
t=[Link](borne1,borne2,nbr d’éléments)
ou bien Y=[Link]([1/17,1/10,1/5,1/2,1,1/2,1/5,1/10,1/17])
Ajout un élément à une liste
[Link]([0,'Merci'])
Nom_liste.append([élément1,élément2,..])
Insertion un élément dans une position n
[Link](3,'Bonsoir')
Nom_liste.insert(n,élément)
Récupérer tous les éléments de la liste du émième au énième
L2[m :n+1]
Récupérer tous les éléments de la liste du premier au énième
L2[:n+1]
Pour récupérer tous les éléments de la liste.
L2[ :]
Supprimer l'élément dans la position 33 de la liste L2
Del L2[3]
La représentation graphique de la fonction f(t)
[Link](t,f(t),color="purple",linestyle="dashed",marker=’^’)
(la ligne est discontinue=dashed) le marker =triangle
[Link](t,f(t),'b-',X,Y,'r*') //représentation de deux fct au meme temps une avec line continue(bleu) et
l’autre en rouge avec des *)
autre methode :
g= lambda x : [Link](x**2)-4*(x**2)+5
x=[Link](1,2,100)
[Link](x,g(x))
Autre exemple : Sur une même figure, représenter le polynôme interpolant les points, en bleu avec
une ligne continue d’épaisseur égal à 2, et les points d’interpolation en utilisant des ’markers’ en
étoiles rouges de tailles égales à 12
P=Interpolation_Lagrange(t,X,Y)
[Link](figsize=(20,10))
[Link](t,P,'b-',X,Y,'r*',linewidth=2,markersize=12)
Autre exemple : rajouter à la figure de la question 4, la représentation graphique de f évaluée en t
avec une ligne discontinue en vert et d’épaisseur 2.
[Link](figsize=(20,10))
[Link](t,P,'b-',X,Y,'r*',t,f(t),'g--',linewidth=2,markersize=12)
Création d’un polynome :
P=Polynimial([1,0,6,1]) ->maaneha p=1+6x2 +x3
Addition de pôlynomes :
R=P+Q
Pour savoir les coefficients :
[Link]
[Link][0]
P(1) //calcul p(x) quand x=1
Matrice à diagonale strictement dominante
def matrice_diag_dominante(A):
n=[Link](A)[0]
etat=True
i=0
while (i<n)and (etat == True):
etat=[Link](A[i,i])>[Link]([Link](A[i,:]))-[Link](A[i,i])
i+=1
return etat
Méthode de Jacobi
def jacobi(A, b, X0, epsilon):
etat=matrice_diag_dominante(A)
if etat==False:
print('La méthode de Jacobi n\'est pas convergente')
else:
M=[Link]([Link](A))
N=M-A
inv_M=[Link](M)
k=0
while [Link]([Link](X0)-b,1)>epsilon:
X0=inv_M.dot([Link](X0))+inv_M.dot(b)
k+=1
return X0,k
Méthode de Gauss-Seidel
def Gauss_seidel (A, b, X0, epsilon):
etat=matrice_diag_dominante(A)
if etat==False:
print('La méthode de Jacobi n\'est pas convergente')
else:
M=[Link](A)
N=M-A
inv_M=[Link](M)
k=0
while [Link]([Link](X0)-b,1)>epsilon:
X0=inv_M.dot([Link](X0))+inv_M.dot(b)
k+=1
return X0,k
Ecriture de polynome : (𝑋)=1+6𝑋2+𝑋3
P=Polynomial([1,0,6,1]) #P(X)=1+6*X^2+1*X^3=1+0*X+6*X^2+1*X^3.
///////////////////-/
def Lagrange(t,i,x):
n=len(x)
L=1
for j in [Link](0,n):
if j!=i:
L*=(t-x[j])/(x[i]-x[j])
return L
def Interpolation_Lagrange(t,x,y):
n=len(x)
P=[Link]((len(t)))
for i in [Link](0,n):
P+=y[i]*Lagrange(t,i,x)
return P
#####################################################
def interpolation_lagrange(t,x,y):methode2
n=len(x)
P=[Link]((len(t)))
for i in [Link](0,n):
L=1
for j in [Link](0,n):
if j!=i:
L*=(t-x[j])/(x[i]-x[j])
P+=y[i]*L
return P
Interpolation de Lagrange methode 3
def Interpolation_Lagrange(t,x,y):
n=len(x)
P=[Link]((len(t)))
for i in [Link](0,n):
P+=y[i]*Lagrange(t,i,x)
return P
Polynome de Lagrange
Determination de coefficient
def coefficients(x,i,j):
pol=Polynomial([1])
if i!=j :
pol=Polynomial([-x[j]/(x[i]-x[j]),1/(x[i]-x[j])])
return pol
Détermination de somme L
def Lagrange(x,i): # les coefficients de polynome de Lagrange (Li)
L=Polynomial([1]) # Initialisation de L
for j in range(len(x)): # par construction de J, i différent de j
if j!=i:
Lij=coefficients(x,i,j) # Appeler la fonction coefficients(x,i,j) pour calculer lij.
L*=Lij # Faire le produit
return L
Polynôme de Lagrange
def polynome_Lagrange(x,y):
P=Polynomial([0])
n=len(x)
for i in [Link](n):
produit=y[i]*Lagrange(x,i)
P+=produit
return P
Affichage
t=[Link](-1.5*[Link],1.5*[Link],100) : L’intervalle [(-3/2)pi , (3/2)pi]
[Link](figsize=(20,10))
[Link](t,P4(t),'r-',t,[Link](t), 'b--',x,[Link](x),'mo',linewidth=3,markersize=12)
[Link]('t',fontsize=30)
[Link](fontsize=20)
[Link](fontsize=20)
[Link](True)
[Link](('Polynome d\'interpolation de Lagrange', 'cosinus', 'points'),fontsize=20, loc = 0)
/////////////////////////////////////////////////
Polynome Newton
def Newton(t,i,x):
n=len(x)
if i==0:
return [Link]((len(t)))
else:
W=1
for j in [Link](0,i):
W*=(t-x[j])
return W
Affichage Newton
x=[Link](-1,2,1)
t=[Link](-1,1,21)
[Link](figsize=(20,10))
[Link](t,Newton(t,0,x),'ro--',t,Newton(t,1,x),'b^--',t, Newton(t, 2,x),'g*--',linewidth=3,markersize=12)
[Link]('t',fontsize=30)
[Link](fontsize=20)
[Link](fontsize=20)
[Link](('W0','W1','W2'),fontsize=20, loc = 0)
[Link](True) [Link](-1,-0.1,"(-1,0)",ha="center",va="top",fontsize=30)
[Link](0,-0.1,"(0,0)",ha="center",va="top",fontsize=30) [Link](1,-
0.1,"(1,0)",ha="center",va="top",fontsize=30)
[Link](-1,1.05,"(-1,1)",ha="center",va="bottom",fontsize=30)
[Link](0,1.05,"(0,1)",ha="center",va="bottom",fontsize=30)
[Link](1,1.05,"(1,1)",ha="center",va="bottom",fontsize=30)
Interpolation de Newton
def Interpolation_Newton(t,x,y):
n=len(x)
P=[Link]((len(t)))
beta=diff_div(x,y)
for i in [Link](0,n):
P+=beta[i]*Newton(t,i,x)
return P
Approximation des Moindres carrés
def PLSA(X,Y,p): # X et Y deux tableaux 1D
n = len(X)
A = [Link]((n,p+1))
for i in [Link](1,p+1):
A[:,i] = X[:,0]**i
Lambda=[Link]([Link](A)).dot([Link](Y))[:,0]
return Polynomial(Lambda)
Affichage
a = -1
b=6
m = 100
[Link](figsize=(10,5))
t = [Link](a,b,100) # on pourra réduire le nombre de points et on prend que deux points seulement
si on cherche une droite
[Link](X,Y,'ro',t,PLSA(X,Y,1)(t),'b--',lw=3,markersize=10)
[Link]('t',fontsize=15)
[Link](fontsize=10)
[Link](fontsize=10)
[Link](('Mesures','Approximation'),fontsize=15, loc = 0)
[Link](True)
rectangle droite composite (Calculer l'erreur d'integration de la méthode composite du rectangle
à droite)
def rectangle_droite_composite(f,a,b,n):
h=(b-a)/n
I=0
for k in [Link](1,n+1):
I+=f(a+k*h)
return h*I
Affichage Approximation
f=lambda x: [Link](-x**2)
t=[Link](-1,1,1000)
x=[Link](-1,1,5)
#x=[Link](-1,1.1,1/2)
[Link](figsize=(20,10))
[Link](True)
[Link](t,f(t),color="blue",linewidth=4)
plt.fill_between(x,f(x),step='pre',color="red",alpha=0.5)
[Link](('$f$','$I_{RD}^c(f)$'),loc=0,fontsize=30)
[Link](fontsize=20)
[Link](fontsize=20)
[Link]('t',fontsize=30)
[Link]('f(t)',fontsize=30)
[Link]('Approximation de $\int_{-1}^1 e^{-t^2}dt$ par la méthode des rectangles à droite (n=4)',
fontsize=20)
d’intégration composite du rectangle du milieu
def RM(f,a,b,n):
h=(b-a)/n
p=n/2
S=0
for i in [Link](0,p):
S+=f(a+(2*i+1)*h)
return 2*h*
La méthode composite de trapèze
def trapèze_composite(f,a,b,n):
h=(b-a)/n
I=h*(f(a)+f(b))/2
for k in [Link](1,n):
I+=h*f(a+k*h)
return I
Affichage approximation
x=[Link](-1,1,5)
[Link](figsize=(20,10))
[Link](True)
[Link](t,f(t),color="blue",linewidth=3)
plt.fill_between(x,f(x),color="red",alpha=0.5)
[Link](('$f$','$I_{RD}^c(f)$'),loc=0,fontsize=30)
[Link](fontsize=20)
[Link](fontsize=20)
[Link]('t',fontsize=30)
[Link]('f(t)',fontsize=30)
[Link]('Approximation de $\int_{-1}^1 e^{-t^2}dt$ par la méthode des trapèzes (n=4)', fontsize=20)
Méthode composite de Simpson
def Simpson_composite(f,a,b,n):
h=(b-a)/n
I=f(a)+f(b)
p=n//2
for k in [Link](0,p):
I+=4*f(a+(2*k+1)*h)
for k in [Link](1,p):
I+=2*f(a+2*k*h)
return h*I/3
Nombre d'itérations
def integrale_precise(f,I,epsilon, methode):
n=2
val =methode(f,a,b,n)
while ([Link](val-I) >epsilon):
n+=1
val=methode(f,a,b,n)
return n
Dichotomie
def dichotomie(f,a,b,epsilon,Nmax):
k=1
if f(a)*f(b) > 0:
print ('f(a) et f(b) sont de meme signe')
else:
while (b-a > epsilon) and (k<=Nmax):
c = (a+b)/2
if f(a)*f(c) < 0:
b=c
elif f(c)==0:
a=c
b=c
else:
a=c
k += 1
return ((a+b)/2, k-1)
Déclaration intégrale
x=[Link]('x')
[Link]([Link](-x),x)
2. Calculer la valeur de l'intégrale ∫𝑒−𝑥 dx [0.1]
[Link]([Link](-x),(x,0,1))
function somme recursive
def somme_rec(n):
if n==0:
return 0
else:
return n+somme_rec(n-1)
Fonction pgcd
def pgcd(x,y):
if x>y:
return pgcd(x-y,y)
elif x<y:
return pgcd(x,y-x)
else:
return x
Fonction puissance
def puissance(a,b):
P=1
for i in [Link](0,b+1):
P=P*a
return P
puissance(2,3)
Affichage méthode d’Euler :
t=[Link](t0, t0+T,N+1)
[Link](figsize=(20, 10))
[Link](t, [Link](-t), 'b',t,EE, 'r*-',linewidth=2,markersize=8)
[Link]("solution de x'=x",fontsize=30)
[Link](('Solution exacte','Méthode d\'Euler'),fontsize=30, loc='best')
[Link](fontsize=20)
[Link](fontsize=20)
[Link]()
def eulerexplicite(f, x0, t0,T,N):
h=T/N
x = [x0]
for k in [Link](0, N):
[Link](x[k]+h*f(t0+k*h,x[k]))
return x
def eulerimplicite_explicite(f, x0, t0,T,N):
x = [x0]
h=T/N
for k in [Link](0, N):
p1 = f( t0+k*h,x[k])
p2 = f( t0+(k+1)*h,x[k] + h*p1)
[Link](x[k] + h*p2)
return x