import numpy as np
import numpy.linalg as alg
import numpy.random as rd
import scipy.special as sp
Sans rentrer les coefficients un à un, déclarer les matrices ci-dessous : $$A = \begin{pmatrix} 5 & 3 & 3 \\ 3 & 5 & 3 \\ 3 & 3 & 5 \end{pmatrix},~~~ B = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 1 & 1 & 0 & 0 \\ 1 & 0 & 1 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}.$$
A=3*np.ones((3,3))+2*np.eye(3)
print(A)
B=np.concatenate((np.ones((4,1)),np.concatenate((np.zeros((1,3)),np.eye(3)),axis=0)),axis=1)
print(B)
[[5. 3. 3.] [3. 5. 3.] [3. 3. 5.]] [[1. 0. 0. 0.] [1. 1. 0. 0.] [1. 0. 1. 0.] [1. 0. 0. 1.]]
Que vaut $ \begin{pmatrix} a_1 \\ \vdots \\ a_n \end{pmatrix} \begin{pmatrix} 1 & \ldots & 1 \end{pmatrix}$ ? En déduire une manière de déclarer la matrice $$\begin{pmatrix} 1 & 1 & \ldots & 1 \\ 2 & 2 & \ldots & 2 \\ \vdots & \vdots & & \vdots \\ 10 & 10 & \ldots & 10 \end{pmatrix}$$
A=np.array([np.arange(1,11)])
M=np.dot(np.transpose(A),np.ones((1,10)))
print(M)
[[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.] [ 2. 2. 2. 2. 2. 2. 2. 2. 2. 2.] [ 3. 3. 3. 3. 3. 3. 3. 3. 3. 3.] [ 4. 4. 4. 4. 4. 4. 4. 4. 4. 4.] [ 5. 5. 5. 5. 5. 5. 5. 5. 5. 5.] [ 6. 6. 6. 6. 6. 6. 6. 6. 6. 6.] [ 7. 7. 7. 7. 7. 7. 7. 7. 7. 7.] [ 8. 8. 8. 8. 8. 8. 8. 8. 8. 8.] [ 9. 9. 9. 9. 9. 9. 9. 9. 9. 9.] [10. 10. 10. 10. 10. 10. 10. 10. 10. 10.]]
On définit la matrice $A=\begin{pmatrix} 1 & 1 & 2 & 0 \\ 1 & -1 & 0 & -2 \\ 0 & 1 & 1 & 1 \\ 1 & 0 & 1 & -1\end{pmatrix}$.
#1.
A=np.array([[1,1,2,0],[1,-1,0,-2],[0,1,1,1],[1,0,1,-1]])
#2.
def lignes(A,i,j,a):
A[i,:]=A[i,:]-a*A[j,:]
return(A)
#3.
def echange(A,i,j):
l=np.copy(A[i,:])
A[i,:]=A[j,:]
A[j,:]=l
return(A)
#4.
lignes(A,1,0,1)
lignes(A,3,0,1)
lignes(A,2,1,-1/2)
lignes(A,3,1,1/2)
array([[ 1, 1, 2, 0],
[ 0, -2, -2, -2],
[ 0, 0, 0, 0],
[ 0, 0, 0, 0]])
La matrice $A$ est de rang 2.
#5.
alg.matrix_rank(A)
2
#6.
def pivot(A):
n=len(A)
for j in range(n-1):
if A[j,j]==0:
for i in range(j+1,n):
if A[i,j]!=0:
echange(A,i,j)
if A[j,j]!=0:
for i in range(j+1,n):
lignes(A,i,j,A[i,j]/A[j,j])
return(A)
pivot(A)
array([[ 1, 1, 2, 0],
[ 0, -2, -2, -2],
[ 0, 0, 0, 0],
[ 0, 0, 0, 0]])
#1.
x=1/np.arange(1,11)**2
print(x)
[1. 0.25 0.11111111 0.0625 0.04 0.02777778 0.02040816 0.015625 0.01234568 0.01 ]
#2.
K=np.arange(1,11)
print("Somme des 1/k^2 entre 1 et 10 :",np.sum(1/K**2))
Somme des 1/k^2 entre 1 et 10 : 1.5497677311665408
#3.
K=np.arange(11)
print("Somme des 1/2^k entre 0 et 10 :",np.sum(1/(2**K)))
Somme des 1/2^k entre 0 et 10 : 1.9990234375
#1.
A=np.arange(0,1001,7)
print(A)
[ 0 7 14 21 28 35 42 49 56 63 70 77 84 91 98 105 112 119 126 133 140 147 154 161 168 175 182 189 196 203 210 217 224 231 238 245 252 259 266 273 280 287 294 301 308 315 322 329 336 343 350 357 364 371 378 385 392 399 406 413 420 427 434 441 448 455 462 469 476 483 490 497 504 511 518 525 532 539 546 553 560 567 574 581 588 595 602 609 616 623 630 637 644 651 658 665 672 679 686 693 700 707 714 721 728 735 742 749 756 763 770 777 784 791 798 805 812 819 826 833 840 847 854 861 868 875 882 889 896 903 910 917 924 931 938 945 952 959 966 973 980 987 994]
#2.
print("Plus grand multiple de 7 inférieur à 1000 :",A[-1])
Plus grand multiple de 7 inférieur à 1000 : 994
#3.
print("Plus petit multiple de 7 supérieur à 1000 :",A[-1]+7)
Plus petit multiple de 7 supérieur à 1000 : 1001
On modélise le nombre de véhicules passant sur une petite route de campagne en une journée par une variable aléatoire $X$ qui suit une loi de Poisson $\mathscr{P}(5)$.
Introduire une matrice $\verb|A|$ de taille $52\times 7$ qui simule une année de circulation, chaque ligne contenant le trafic de chaque jour d'une semaine. La matrice A contient alors $52 \times 7$ nombres tirés suivant la loi $\mathscr{P}(5)$.
Déterminer le nombre maximal de véhicules circulant sur la route en une journée durant l'année, puis le nombre maximal de véhicules un mercredi durant l'année.
Déterminer les numéros des semaines où la route a connu son maximum de fréquentation.
Déterminer le nombre de jours où la route a connu son minimum de fréquentation.
En une seule ligne de commande, calculer le nombre moyen de véhicules par jour durant ces 364 jours. Recommencez plusieurs fois en recréant la matrice A. Que constate-t-on ? Était-ce prévisible ?
En une seule ligne de commande, évaluer la probabilité qu'une journée voie passer 8 véhicules ou plus. Calculer la valeur exacte de cette probabilité.
#1.
A=rd.poisson(5,(52,7))
#2.
print("Nombre max de voitures en une journée :",np.max(A))
print("Nombre max de voitures le mercredi :",np.max(A[:,2]))
Nombre max de voitures en une journée : 11 Nombre max de voitures le mercredi : 9
#3. Tableau des fréquentations par semaine :
F=np.sum(A,axis=1)
print("Numéro des semaines réalisant le maximum de trafic :", np.where(F==max(F))[0]+1)
Numéro des semaines réalisant le maximum de trafic : [29]
#4.
print("Nombre de jours ou le trafic est minimal :",np.sum(A==np.min(A)))
Nombre de jours ou le trafic est minimal : 6
#5.
print("Moyenne de fréquentation par jour :",np.mean(A))
Moyenne de fréquentation par jour : 4.873626373626373
for i in range(10):
A=rd.poisson(5,(52,7))
print(np.mean(A))
4.983516483516484 5.008241758241758 5.164835164835165 4.917582417582418 5.162087912087912 5.181318681318682 4.826923076923077 4.887362637362638 5.035714285714286 4.934065934065934
La moyenne est toujous très proche de 5, ce qu'on attendait car l'espréance d'une variable aléatoire qui suit la loi $\mathcal{P}(5)$ est 5.
#6.
A=rd.poisson(5,10**6)
print("Estimation de la probabilité de 8 véhicules ou plus :",np.mean(A>7))
Estimation de la probabilité de 8 véhicules ou plus : 0.133245
#Calcul de la probabilité
K=np.arange(0,8)
print("Probabilité d'avoir 8 véhicules ou plus :",1-sum(np.exp(-5)*5**K/sp.factorial(K)))
Probabilité d'avoir 8 véhicules ou plus : 0.13337167407000727
Écrire un programme permettant de calculer $\sum_{k=1}^{n} \frac{(-1)^{k-1}}{k}$ pour une valeur de $n$ entrée par l'utilisateur. On proposera pour cela deux méthodes, l'une utilisant la fonction $\verb|sum|$, l'autre à l'aide d'une boucle $\verb|for|$.
On peut montrer que la série $\sum \frac{(-1)^{n-1}}{n}$ converge et que sa somme vaut $\ln (2)$. Écrire un programme permettant de déterminer le plus petit entier naturel $n$ pour lequel $\left|S_{n}-\ln (2)\right| \leq$ $10^{-3}$, où $\left(S_{n}\right)$ désigne la suite des sommes partielles de cette série.
#1.
print("Entrer n :")
n=int(input())
K=np.arange(1,n+1,1)
print("Somme des (-1)^(k-1)/k de 1 à",n,":",sum((-1)**(K-1)*(1/K)))
Entrer n : 10 Somme des (-1)^(k-1)/k de 1 à 10 : 0.6456349206349207
S=0
for k in range(1,n+1):
S+=(-1)**(k-1)/k
print("Somme des (-1)^(k-1)/k de 1 à n :",S)
Somme des (-1)^(k-1)/k de 1 à n : 0.6456349206349207
#2.
eps=1e-3; S=0; n=0
while (abs(S-np.log(2))>eps):
n+=1
S+=(-1)**(n-1)/n
print("Plus petit rang tel que |S_n-ln(2)|<=eps :",n)
Plus petit rang tel que |S_n-ln(2)|<=eps : 500
Soient $\left(u_{n}\right)_{n \in \mathbb{N}^{*}}$ et $\left(v_{n}\right)_{n \in \mathbb{N}^{*}}$ les suites définies par $\displaystyle u_{n}=\sum_{k=1}^{n} \frac{1}{k^{2}}$ et $v_{n}=u_{n}+\frac{1}{n}$, pour tout $n \in \mathbb{N}^{*}$.
Montrer que les suites $\left(u_{n}\right)_{n \in \mathbb{N}^{*}}$ et $\left(v_{n}\right)_{n \in \mathbb{N}^{*}}$ sont adjacentes.
Écrire un programme qui donne une approximation de $\displaystyle \sum_{k=1}^{+\infty} \frac{1}{k^{2}}$ à $\varepsilon$ près pour $\varepsilon>0$ donné.
On sait que la somme $S=\sum_{k=1}^{+\infty} \frac 1 {k^2}$ est dans l'intervalle $[u_n,v_n]$ pour tout $n\in \mathbb{N}$. On cherche alors un entier $n$ tel que l'intervalle $[u_n,v_n]$ soit de longueur inférieure à $\varepsilon$. On aura alors assuré que $|u_n-S|\leq \varepsilon$.
Comme $v_n-u_n = \frac 1 n$, il suffit de s'assurer que $\frac 1 n \leq \varepsilon$, c'est-à-dire que $n\geq \frac 1 \varepsilon$.
eps=1e-5
n=np.ceil(1/eps) #calcul de n pour avoir n >= 1/eps
U=np.sum(1/np.arange(1,n+1)**2) #calcul de S_n pour le n trouvé
print("Estimation de la somme à ",eps," près :",U)
print("Erreur :",abs(np.pi**2/6-U)) #vérification : on sait que S=pi^2/6
Estimation de la somme à 1e-05 près : 1.644924066898227 Erreur : 9.999949999395241e-06
Ecrire une fonction $\verb|trace(A)|$ prenant en entrée une matrice $\verb|A|$, et retournant la trace de $A$ si $A$ est carrée, et retournant un message d'erreur si $A$ n'est pas carrée.
def trace(A):
s=np.shape(A)
if s[0]!=s[1]:
print("La matrice n'est pas carrée.")
else:
T=0
for i in range(s[0]):
T+=A[i,i]
return(T)
#plus rapide :
def trace(A):
s=np.shape(A)
if s[0]!=s[1]:
print("La matrice n'est pas carrée.")
else:
return(sum([A[i,i] for i in range(s[0])]))
A=np.ones((2,3))
trace(A)
La matrice n'est pas carrée.
B=np.ones((3,3))
trace(B)
3.0
\binom{1}{0} & \binom{1}{1} & \ldots & \binom{1}{n} \\
\vdots & \vdots & \vdots & \vdots \\
\binom{n-1}{0} & \binom{n-1}{1} & \ldots & \binom{n-1}{n-1}
\end{pmatrix}.$$On a $\displaystyle \binom{n}{k} = \frac{\displaystyle \prod_{i=n-k+1}^n i}{\displaystyle \prod_{i=1}^k i}.$
def binomial(k,n):
return np.prod(np.arange(n-k+1,n+1))/np.prod(np.arange(1,k+1))
#2.
n=5
C=np.zeros((n,n))
for i in range(n):
for j in range(n):
C[i,j]=binomial(j,i)
print(C)
[[1. 0. 0. 0. 0.] [1. 1. 0. 0. 0.] [1. 2. 1. 0. 0.] [1. 3. 3. 1. 0.] [1. 4. 6. 4. 1.]]
#3.
n=5
C=np.concatenate((np.ones((n,1)),np.zeros((n,n-1))),axis=1)
for i in range(1,n):
for j in range(1,i+1):
C[i,j]=C[i-1,j-1]+C[i-1,j]
print(C)
[[1. 0. 0. 0. 0.] [1. 1. 0. 0. 0.] [1. 2. 1. 0. 0.] [1. 3. 3. 1. 0.] [1. 4. 6. 4. 1.]]
Écrire une fonction $\verb|Prod(A,B)|$ qui prend en entrée deux matrices $\verb|A|$ et $\verb|B|$, et qui renvoie leur produit matriciel $AB$ lorsqu'il est bien défini (sans utiliser la fonction $\verb|np.dot|$), et renvoie un message d'erreur lorsqu'il n'est pas défini.
def Prod(A,B):
(n,p)=np.shape(A)
(m,q)=np.shape(B)
if p!=m:
print("Mauvaises dimensions")
else:
C=np.zeros((n,q))
for i in range(n):
for j in range(q):
for k in range(p):
C[i,j]+=A[i,k]*B[k,j]
return(C)
#1
def stoch(A):
if np.min(A)<0:
return False
n=np.shape(A)[0]
for i in range(n):
if np.sum(A[i,:])!=1:
return False
return True
#2
def bistoch(A):
return stoch(A) & stoch(np.transpose(A))
On dit qu'une matrice carrée $A\in \mathscr M_n(\mathbb R)$ est à diagonale strictement dominante si pour tout $i\in [| 1,n |]$, on a $|a_{i,i}| > \sum\limits_{j\not=i} |a_{i,j}|$.
Écrire une fonction $\verb|Diagdom(A)|$ qui prend en entrée une matrice $\verb|A|$ et qui renvoie $\verb|True|$ si $\verb|A|$ est à diagonale strictement dominante, et $\verb|False|$ sinon.
def Diagdom(A):
n=np.shape(A)[0]
for i in range(n):
if 2*abs(A[i,i])-np.sum(A[i,:])<=0:
return False
return True