import numpy as np

import matplotlib.pyplot as plt

##### I. manipulation de tableaux numpy ####

A=np.array([[3,0,-2],[1,0,4],[0,1,3.]]) #Le '.' est là pour avoir un
type float
print('Question 1')
print('A = ')
print(A)
print('bloc {0,1} x {1,2} : ')
print(A[0:2,1:3])
#On s'arrête à i-1, comme dans range(n), et les extrêmités peuvent
être exclues :
print('\n')
print(str(A[:2,1:])+' (syntaxe [:2,1:])')
print('A>2 : ')
print(A>2)
print('A[A>2] : ')
print(A[A>2])
print(type(A[A>2])) #non demandé : testez ce qui vous fait envie,
essayez de répondre par des tests aux questions que vous vous posez.
print('\n Question 2')
print('taille : '+str(np.size(A)))
print('forme : '+str(np.shape(A)))
print('colonne du milieu :')
B=A[:,1]
print('B = '+str(B))
print('taille : '+str(np.size(B)))
print('forme : '+str(np.shape(B)))
print('\n Question 3')
B=np.zeros((4,6))
B[0:3,0:3]=A #ou A[:3,:3]
B[1:4,3:6]=A #ou A[1:,3:]
print(B)

print('\n Question 4')

Abis=A
Abibis=A[:]
Acop=np.copy(A)
def Affiche():
print('A =A =A[:] =np.copy(A)')
print(A)
print(Abis)
print(Abibis)
print(Acop)
print('---------------------')
Affiche()
A[1,2]=99
Affiche()
1
 #seul np.copy(A) ne change pas : le comportement n'est pas
complètement celui des listes

##### II. Calcul de l'inverse ####

# Q1 : Fonction cramer

# Il suffit de programmer le calcul du déterminant de la matrice A

dont la
#colonne j a été remplacée par Y (en fait par Y [0], i.e. la seule
colonne de Y )
#C’est pour cela que les matrices n’ont pas été codées comme
d’habitude. On
#stocke les résultats dans une liste qui constitue la seule colonne
de X (ne pas
#oublier les doubles crochets).

def Cramer(A,Y):
X = []
n = len(A)
for j in range(n):
B = copy.deepcopy(A) #A ne doit pas être modifiée
B[j] = copy.deepcopy(Y[0]) #un deepcopy un peu abusif
X = X + [ det(B)/det(A) ] #un append serait quand même mieux,
#sans compter le recalcul de det(A) systématique !
return [X]
# Q2
# (cette question ne fait pas intervenir l’informatique) Expliquer
que l’unique solution du système pour Y égale à la colonne nulle,
sauf le coefficient de la ligne i qui vaut 1, est la ie colonne de
A^−1.
# En déduire une manière de trouver A^−1 par résolutions successives
de plusieurs systèmes.
#La solution est X = A^−1Y qui est la ie colonne de A^−1 avec cette Y
. Il suffit donc de résoudre ces systèmes successivement pour toutes
ces matrices de second membre : on obtient à chaque étape une
nouvelle colonne de A^−1.

def Inverse(A):
Inv = []
n = len(A)
for i in range(n):
Y = [[ 0 for j in range(n) ]] #toujours un peu genes avec ces
doubles [ ]
Y[0][i] = 1
Inv = Inv + Cramer(A,Y)
return Inv
#On effectue pour chaque colonne (n+1)! calculs pour les
déterminants, soit au final (n+1)(n+1)! calculs. Cette méthode n’a
aucun intérêt pratique.En fait, le gros défaut vient de la manière de
calculer le déterminant : un méthode par Pivot de Gauss est bien plus
2
calculer le déterminant : un méthode par Pivot de Gauss est bien plus
profitable.

##### III. Courbes implicites ####

# Q1
# La comparaison à 0 d’un flottant est une mauvaise idée : problème
lié à l’arrondi. Il faut lui substituer une évaluation de l’erreur
comme par exemple abs(f(x,y)) <= eps avec un eps fixé à la précision
souhaitée.

# Q2
#On doit générer les listes d’abscisses et d’ordonnées séparément. Il
suffit de faire varier x et y de 0 à 1 avec un pas de 1/n , de tester
l’appartenance à la courbe, et de stocker dans le cas où cela
convient.
import matplotlib.pyplot as plt
f=lambda x,y:x**2+y**2-1
n=7000
x =0
eps=1e-6
abscisse , ordonnee = [] , []
for i in range(0,n+1): #et oui, il faut prendre i=n
y = -1 #ici et pas avant le for i
for j in range(0,n+1):
if abs(f(x,y)) <= eps:
abscisse = abscisse + [x]
ordonnee = ordonnee + [y]
y = y + 1/n #surtout pas dans le if !
x = x + 1/n #et pas dans le for j
plt.plot( abscisse , ordonnee , 'r-' )
plt.axis("equal")
plt.show() #ces deux lignes n'étaient pas demandées.

#### Exercice : Système de Lotka Voltera (proies-prédateurs)

########

def simul(x0,y0,tmax,n,a,b,c,d):
y=y0
x=x0
ly=[y0]
lx=[x0]
lt=[0]
h=tmax/n
t=0
for j in range(0,n):
t,x,y = t+h,x*(1+a*h-b*h*y),y*(1-d*h+c*h*x)
lx.append(x)
ly.append(y)
3
 lt.append(t)
return lt,lx,ly
res=simul(1,1,3,500,1,1,2,7)
plt.plot(res[1],res[2])
plt.show()