ECS1 : Initiation à SciLab

Transcription

Alain GUICHET
5 janvier 2017
ii
mise à jour : 5 janvier 2017
Alain Guichet - LPo Touchard-Washington, Le Mans
Table des matières
1 L'environnement de travail SciLab
1.1
1.2
1.3
1.4
Démarrage . . . . . . . . . . . .
Travailler en mode console . . . .
Travailler sous l'éditeur SciNotes
Exercices . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2 Calcul matriciel
2.1 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3 Instruction itérative for ... end
3.1 Exemples . . . . . . . . . .
3.1.1 Une suite récurrente
3.1.2 Une somme . . . . .
3.2 Syntaxe de l'instruction for
3.3 Exercices . . . . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
... end .
. . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Une courbe, une gure . . . . . . . . . . . . . . . . . . . . . . .
Plusieurs courbes sur une même gure . . . . . . . . . . . . . .
Des courbes sur gures distinctes mais dans une même fenêtre
À partir d'une fonction . . . . . . . . . . . . . . . . . . . . . . .
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4 Tracé de courbes de fonctions dans le plan
4.1
4.2
4.3
4.4
4.5
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5 Instruction conditionnelle if ... end
5.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Syntaxe de l'instruction if ... end . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
1
1
1
2
3
3
4
5
5
5
5
5
6
7
7
7
7
8
8
9
9
9
10
6 Instruction itérative while ... end
11
7 Calcul approché d'intégrales
13
8 Variables aléatoires : simulations et représentations graphiques
15
9 Algèbre linéaire
17
10 Lois de probabilité
19
6.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Syntaxe de l'instruction while ... end . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.1 Méthodes des rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 Application à la détermination d'une primitive particulière . . . . . . . . . . . . . . . . . . . . . . . .
7.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1 Simulation de variables discrètes à valeurs entières . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 Fonction de répartition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1 Fonctions matricielles algébriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1 Fonction grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
iii
11
11
12
13
13
13
15
15
16
17
17
19
19
iv
Chapitre 1
1
Chapitre 1
L'environnement de travail SciLab
1.1 Démarrage
Au lancement du programme (ouverture d'une session), on découvre dans la fenêtre :
un navigateur de chiers,
une console,
un tableau récapitulatif des variables utilisées,
un historique des commandes,
... (on peut obtenir d'autres fenêtres)
1.2 Travailler en mode console
Dans la console, le logiciel fonctionne comme une calculatrice et attend la saisie d'une commande derrière le
prompt noté -->. Saisir successivement :
1+1 (puis validation, bien sûr)
x=3
(x+2)^3
ans/1.6
floor(ans)
x=2*x
sqrt(x)
y=-5
exp(x+y)
abs(-6)
La variable ans contient donc le résultat du dernier calcul eectué. On peut aussi constater que le tableau des variables
s'enrichit au fur et à mesure.
Saisir successivement :
clear (eace tous les calculs de la console ainsi que toutes les variables existantes)
%e
%pi
%i
Ces trois dernières instructions correspondent aux trois constantes usuelles prédénies.
On peut écrire une succession de calculs, séparés par un point-virgule : seul le résultat nal sera aché. Exemple :
x=9;y=1;log(x+y)
Remarquer que le logarithme népérien se note log et non ln.
Dénition 1.1 (Opérations usuelles) :
Les opérations usuelles sont : +, -, *, / et ^.
Les fonctions usuelles sont : log, exp, cos, sin, tan, sqrt, floor, abs.
Remarque :
Bien d'autres fonctions préexistent dans SciLab mais ce sont presque les seules exigibles dans le programme ociel.
1.3 Travailler sous l'éditeur SciNotes
Ouvrir l'éditeur de texte SciNotes (Applications/SciNotes) : cela permet de modier et de sauvegarder plus
facilement son travail, notamment lorsque le nombre d'instructions est important.
Recopier dans l'éditeur le texte suivant :
function y=f(x) // début de la définition d'une nouvelle fonction
y=log(1+x)
endfunction // fin de la définition de cette nouvelle fonction
disp(f(2)) // utilisation de cette nouvelle fonction
Sauvegarder et exécuter ce script (le résultat s'ache dans la console).
Remplacer la dernière ligne par :
t=input("Donner un réel : ") // utilisation de cette nouvelle fonction
disp(f(t))
2
Chapitre 1
Dénition 1.2 (Instuctions de saisie et d'achage) :
Pour saisir un nombre entier ou réel, on utilise l'instruction input, avec ou sans message d'information :
nom_de_variable = input() // pas de message
nom_de_variable = input(Mon message) // avec un message
Pour acher le résultat d'un calcul, on utilise l'instruction disp :
disp(mon_calcul) // affiche le résultat du calcul
disp(mon_calcul_1,...,mon_calcul_n) // affiche les résultats mais dans l'ordre inverse
Remarques :
Remarquer les diérents changements de couleurs dans le script. Cette coloration syntaxique témoigne que
l'interpréteur du script reconnaît un certain nombre de mots clé du langage et ainsi que les commandes écrites
ne comportent pas d'erreur d'orthographe.
Tout texte qui suit le marqueur // est considéré comme un commentaire (remarquer la coloration syntaxique
diérente) donc ne sera pas traité durant l'exécution. Un commentaire facilite la relecture de son script.
On ne peut pas exécuter un script sans l'avoir enregistré (sinon, on exécute sa précédente version).
1.4 Exercices
Exercice 1.1
En une seule instruction, calculer 20!
Exercice 1.2
Dénir la fonction f : x 7→
Exercice 1.3
Dénir la fonction g : t 7→
2
x
√1 e− 2
2π
. Calculer f (ln(8)).
sin(t)+cos(t)
2 sin(t) sin(3t) .
Calculer g
π
8
.
Exercice 1.4
Écrire un script qui comporte une fonction et qui, après avoir saisi un réel x0 , calcule et ache les réels
f (x0 ), f (x0 + 0.1), f (x0 + 0.2), . . . , f (x0 + 0.9), f (x0 + 1)
pour, successivement, les fonctions suivantes :
s
f : R → R, x 7→
x + ex
2 − cos x1
f : R → R, x 7→ ln
|x + bxc|
x + 1 − bxc
Exercice 1.5
Écrire un script saisissant trois réels x, y, z et calculant les réels A(x, y, z), G(x, y, z), H(x, y, z) et Q(x, y, z) dénis
par :
x+y+z
A(x, y, z) =
3
G(x, y, z) =
√
3
xyz
H(x, y, z) =
r
3
1
x
+
1
y
+
1
z
Q(x, y, z) =
x2 + y 2 + z 2
3
Tester sur plusieurs triplets de réels strictement positifs (x, y, z) et classer dans l'ordre croissant les quatre réels obtenus.
Exercice 1.6
Déterminer le module et un argument des complexes (penser à utiliser l'aide de SciLab) :
z1 =
(1 + 2i)(2 − i)
1+i
z2 =
1+i
1−i
z3 = ei 3 − ei 4
π
π
Chapitre 2
3
Chapitre 2
Calcul matriciel
2.1 Matrices
Dénition 2.1 (Matrice) :
Une matrice est un tableau de nombre à double entrée (lignes/colonnes) : le marqueur de début/n est le crochet, les
matrices sont saisies par ligne séparées d'un
, les éléments d'une ligne sont séparées par une virgule.
point-virgule
Dénition 2.2 (Taille d'une matrice) :
length(A) : nombre total de coecients de la matrice A.
[n,p]=size(A) : la variable n (resp. p) contient alors le nombre de lignes (resp. colonnes) de la matrice A.
Dénition 2.3 (Matrices pré-construites) :
zeros(n,p) : matrice nulle à n lignes et p colonnes.
ones(n,p) : matrice remplie de 1 sur n lignes et p colonnes.
eye(n,p) : matrice unité avec des 1 en diagonale et 0 ailleurs (fonctionne aussi avec n 6= p).
rand(n,p) : matrice aléatoire à n lignes et p colonnes, chaque coecient est choisi au hasard dans [0, 1[.
linspace(a,b,n+1) : matrice-ligne de premier terme a, de dernier b et contenant n + 1 termes en progression
arithmétique (donc de raison b−a
n ).
[a:r:b] : matrice-ligne de premier terme a, en progression arithmétique de raison r et dont le dernier terme
est soit exactement b soit le plus grand terme possible inférieur à b. Si le nombre r est manquant ([a:b]) alors
la raison vaut 1 par défaut.
Dénition 2.4 (Opérations constructivistes) :
Concaténation de deux matrices :
A=[B,C] : les colonnes de A sont les colonnes de B suivies de celles de C pourvu que B et C aient le même
nombre de lignes,
A=[B;C] : les lignes de A sont les lignes de B suivies de celles de C pourvu que B et C aient le même nombre
de colonnes.
Extraction d'une sous-matrice :
A(i,:) : ligne i de A,
A(:,j) : colonne j de A,
A(n1:n2,p1:p2) : sous-matrice de A constituée des lignes n1 à n2 et des colonnes p1 à p2 de A.
A(L,C) : plus généralement, A étant une matrice à n lignes et p colonnes, L une matrice-ligne dont les
coecients sont des entiers de J1, nK, C matrice-ligne dont les coecients sont des entiers de J1, pK, désigne
la matrice comportant length(L) lignes et length(C) colonnes et pour coecients les réels Ai,j pour tout
i ∈ L et tout j ∈ C .
Extraction d'un coecient particulier :
A(i,j) : coecient de la ligne i et colonne j de A,
A(k) : kème coecient de A en les comptant de haut en bas et gauche à droite et .
Si A est une matrice à n lignes et p colonnes, si i ∈ J1, nK et si j ∈ J1, pK, on : A(i,j)=A((j-1)*n+i).
Recherche de coecients ayant une certaine propriété :
L=find(A>0) : fournit une matrice-ligne contenant la liste des indices k tels que A(k) > 0.
L=find(A==0) : fournit une matrice-ligne contenant la liste des indices k tels que A(k) = 0.
[L,C]=find(A>=0) : fournit deux matrices-lignes contenant la liste L des numéros de ligne i et la liste C
des numéros de colonnes j telles que A(i, j) > 0.
Exemples :
A=[1,2,3;4,5,6] ; length([1,2,3;4,5,6])
B=size(A)
n=7 ; C=[1:n;2:n+1;3:n+2] ; C([2,3],[1,3])
D=[1:2:9;2:2:10] ; D([3,1],[1,3])
E=[linspace(0,10,6);linspace(1,11,6)] ; find(E==4)
Dénition 2.5 (Opérations mathématiques) :
Transposée d'une matrice A : A' (pour permuter les lignes et les colonnes).
Somme de deux matrices de même taille : A+B (somme terme à terme).
Produit ( ociel ) de deux matrices : A*B, A^k (puissance k), inv(A) (inverse : A ∗ A−1 = I ).
Opérations termes à termes : A.*B, A./B, A.^k, log(A), ...
4
Chapitre 2
Dénition 2.6 (Fonctions matricielles) :
sum(A) : calcule la somme de tous les éléments de A.
prod(A) : calcule le produit de tous les éléments de A.
mean(A) : calcule la moyenne de tous les éléments de A.
2.2 Exercices
Exercice 2.1

1
1

.
1. Construire la matrice à n lignes et n colonnes (n fourni par l'utilisateur) : 
 ..

1
1


1 2 . . . n n + 1 . . . 2n − 1 2n
2. (a) Construire la matrice A = 2 4 . . . 2n 2n + 2 . . . 4n − 2 4n.
3 6 . . . 3n 3n + 3 . . . 6n − 3 6n

n + 1 . . . 2n − 1 2n 1
(b) Transformer la matrice A en la matrice B = 2n + 2 . . . 4n − 2 4n 2
3n + 3 . . . 6n − 3 6n 3
1
0
...
...
0
1
...
...
..
.
2
4
6
...
...
...

1 1
0 1

.. .. 
.
. .


0 1
1 1

n
2n.
3n
Exercice 2.2
1. En une seule instruction, calculer 30!
n!
2. Estimer la valeur de la limite : lim n n √
. Interpréter ce résultat.
n→+∞
2πn
e
1k + 2k + 3k + · · · + nk
? Interpréter ce résultat.
n→+∞
nk+1
k+1
4. Calculer les moyennes arithmétique, géométrique, harmonique et quadratique des entiers de 1 à n :
v
!
u n
n
n
u1 X
1
1X
1X
t
k
G = exp
ln(k)
H=
k2
A=
Q
=
n
n
n
n
1X1
3. Pour k xé, que peut-on prédire de la limite : lim
k=1
k=1
k=1
n
k=1
k
L'ordre des ces quatre nombres dépend-il de n ?
Exercice 2.3
Écrire un script choisissant une matrice aléatoire A à 1000 lignes et 1000 colonnes puis construisant une matrice-ligne
F dont les termes sont les fréquences d'apparition des termes de A inférieurs respectivement à 0.1, 0.2, . . . , 0.9.
Exercice 2.4
Soit r un réel non nul, a un réel quelconque et m un entier naturel non nul. On considère la suite arithmétique (un )n∈N
de raison r (non nulle) et de terme de rang m le réel a. Écrire une matrice à trois lignes de sorte que la première ligne
comporte les termes de rang 0, 1, 2, . . . , 2m de la suite (un ), la deuxième ligne comporte les mêmes termes dans l'ordre
contraire, la troisième ligne est égale à la somme des deux premières. Tester avec diérents triplets (r, a, m).
Exercice 2.5
Calculer la somme : S =
1
6 X
6
X
i=1 j=i
ai,j où A =
1
2
 31

 41

 51

1
6
1
1
2
2
2
3
2
4
2
5
2
6
2
1
3
2
3
3
3
4
3
5
3
6
3
1
4
2
4
3
4
4
4
5
4
6
4
1
5
2
5
3
5
4
5
5
5
6
5
1
6
2
6
3
6 .
4
6
5
6
6
6

Exercice 2.6
1. Recopier et tester le programme ci-contre.
2. Commenter les diérentes lignes du programme.
3. À quoi sert-il ?
function y=f(t)
y=exp(-t^2/2)/sqrt(2*%pi)
endfunction
x=[-5:0.1:5]' ; y=feval(x,f)
disp([x,y])
Chapitre 3
5
Chapitre 3
Instruction itérative
for ... end
3.1 Exemples
3.1.1
Une suite récurrente
On souhaite calculer le terme u100 de la suite dénie par : u0 = 1 et ∀n ∈ N, un+1 = e−un .
Recopier et tester les programmes suivants :
n=input("Donner un entier n : ")
u=input("Donner un réel u0 : ")
for k=1:n ; u=exp(-u) ; end
disp(u)
n=input("Donner un entier n : ")
u=zeros(1,n+1)
u(1)=input("Donner un réel u0 : ")
for k=1:n ; u(k+1)=exp(-u(k)) ; end
disp(u(n+1))
Que se passe-t-il lorsque n tend vers +∞ ? Cette conjecture change-t-elle lorsqu'on modie la valeur de u0 ?
3.1.2
Une somme
On souhaite calculer le terme S100 de la suite dénie par Sn = nk=0 xk! où x est un réel qui sera fourni. On
transforme cette suite en une suite récurrente (et même deux suites récurrentes) :
P
(
u0
S0
=1
= u0
(
et
∗
∀k ∈ N ,
uk
Sk
k
= uk−1 × xk
= Sk−1 + uk
Recopier et tester le script qui suit :
n=input("n=") ; x=input("x=")
u=1 ; S=u
for k=1:n
u=u*x/k
S=S+u
end
disp(S)
3.2 Syntaxe de l'instruction for ... end
Nous avons une première instruction permettant de répéter une séquence d'instructions autant de fois que voulu :
autant de fois, ici, qu'il y a de valeurs dans une certaine liste.
Dénition 3.1 :
Syntaxe sur une ligne unique (généralement pour une ou deux instructions) :
for mon_compteur=[liste_des_valeurs] instruction ; ... ; end
Syntaxe sur plusieurs lignes (facilite la (re)lecture lorsqu'il y a plusieurs instructions) :
f or mon_compteur=[liste_des_valeurs]
end
instruction1
...
Remarques :
L'éditeur indente automatiquement les instructions pour les mettre en évidence, est sensible à la casse (il y a
de modication de la couleur des mots importants si on écrit FOR à la place de for).
La [liste_des_valeurs] est une matrice ligne de réels, souvent entiers et souvent une suite arithmétique mais
il n'y a nulle obligation (exemple : for k=[0.1:0.2:0.9] disp(k) ; end).
6
Chapitre 3
3.3 Exercices
Exercice 3.1
k +1
Soit a ∈ R. On pose : u0 = a et uk+1 = 2u
uk +1 pour tout k ∈ N.
1. Calculer un pour un entier n fourni par l'utilisateur. La suite (un ) converge-t-elle ?
P
2. Calculer nk=0 uk pour un entier n fourni par l'utilisateur. Cette somme converge-t-elle lorsque n tend vers
+∞ ?
Exercice 3.2
1. Soit a ∈ R. Calculer un lorsque : u0 = a et uk+1 = (1 − a)uk + a pour tout k ∈ N.
2. Calculer u10000 pour tout a ∈ 10i | i ∈ J−10, 30K . On donnera le résultat sous la forme d'une matrice colonne.
Exercice 3.3
Soit (a, b) ∈ R2 . Calculer un lorsque : u0 = a, u1 = b et uk+2 = uk+1 + uk pour tout k ∈ N.
Exercice 3.4
(
Soit (a, b) ∈ ]0, +∞[ . Calculer un et vn lorsque :
2
Exercice 3.5
En utilisant la relation
n
k
=
n n−1
k k−1
, calculer
n
k
u0
v0
=a
et
=b
(
uk+1
vk+1
et vérier que
20
10
k
= uk +v
pour tout k ∈ N.
√2
= uk vk
= 184756.
Exercice 3.6
1. À l'aide de la formule d'addition de Pascal, construire le triangle de Pascal dans une matrice de taille n, l'entier
n étant fourni par l'utilisateur.
2. À l'aide de la formule d'addition de Pascal généralisée rappelée ci-dessous, construire le triangle de Pascal dans
une matrice de taille n, l'entier n étant fourni par l'utilisateur. Pour 0 6 k 6 h :
X
h h
i
=
k
k−1
i=k
Exercice 3.7
Soit A la matrice carrée de taille n dont la diagonale ne comporte que des 2 et dont tous les autres coecients sont
2
égaux à 1. On pose : B0 = A et Bk+1 = 21 (Bk + Bk−1 A) pour tout entier k. Calculer B10 et B10
. Que constate-t-on ?
Exercice3.8
1
0
Soit A = 
0
0
1
1
0
0
1
1
1
0

1
1
. Calculer Pn
k=0
1
1
1 k
k! A
pour n = 100.
Chapitre 4
7
Chapitre 4
Tracé de courbes de fonctions dans le plan
4.1 Une courbe, une gure
Tester successivement dans la console :
x=[-1:1:2] ; y=x.^2 ; plot2d(x,y)
x=[-1:0.5:2] ; y=x.^2 ; plot2d(x,y)
x=[-1:0.1:2] ; y=x.^2 ; plot2d(x,y)
x=[-1:0.01:2] ; y=x.^2 ; plot2d(x,y)
Dénition 4.1 :
Soit x et y deux matrices-lignes (ou colonnes) de même taille (1, n). Soit A1 , . . . , An les points de coordonnées
(x(1), y(1)), . . . , (x(n), y(n)). L'instruction plot2d(x,y) trace les segments [A1 , A2 ], . . . , [An−1 , An ].
Remarques :
Par défaut, le logiciel adapte automatiquement la fenêtre de visualisation selon les coordonnées des diérents
points, les graduations sont placées en bas du graphique pour les abscisses et à gauche pour les ordonnées.
Si on tourne la molette de la souris, on obtient un agrandissement/réduction.
On peut ajouter des options à cette instruction (titre, légende des axes, couleurs, position des axes, cadre autour
de la gure ... ; lire l'aide). Par exemple :
plot2d(x,y,5,rect=[-2,-1,3,5],leg=y=x^2,axesflag=5,frameflag=4)
avec couleur (1 : noir, 2 : bleu, 3 : vert, 4 : cyan, 5 : rouge, 6 : magenta, 7 : jaune), fenêtre [xmin , ymin , xmax , ymax ],
légende, axes au centre de la fenêtre, repère orthonormé.
Mais le plus simple est de modier ces paramètres dans la fenêtre de la gure (Édition / Propriétés de la gure
ou Propriétés des axes).
4.2 Plusieurs courbes sur une même gure
Dénition 4.2 :
Soit x une matrice-colonne et y une matrice ayant autant de lignes que x. L'instruction plot2d(x,y) trace autant de
courbes que la matrice y a de colonnes, toutes étant rapportées à la colonne x pour les abscisses.
Remarques :
On peut ajouter des options à cette instruction (une couleur par courbe, une légende par courbe ...) :
x=[0:0.01:%pi*6]' ; y=[cos(x) cos(x+1*%pi/2) cos(x+2*%pi/2) cos(x+3*%pi/2)] ;
plot2d(x,y,[7,6,5,3],leg=cos@cos1@cos2@cos3)
On peut toutefois continuer à travailler avec des lignes, les graphiques étant alors construits successivement :
x=[0:0.01:1];y1=2*x-1;y2=x.^2;plot2d(x,y1);plot2d(x,y2)
est équivalent à : x=[0:0.01:1]';y1=2*x-1;y2=x.^2;plot2d(x,[y1,y2])
Si la fenêtre de dessin n'est pas fermée, toute nouvelle courbe est tracée en plus des précédentes.
4.3 Des courbes sur gures distinctes mais dans une même fenêtre
Dénition 4.3 :
L'instruction subplot(n,p,k) indique que le prochain graphique sera positionné dans la fenêtre courante devant
contenir n × p graphiques répartis sur n lignes et p colonnes en position (i, j) telle que k = p(i − 1) + j .
Exemples :
x=[0:0.01:1];y1=2*x-1;y2=x.^2;subplot(1,2,1);plot2d(x,y1);subplot(1,2,2);plot2d(x,y2)
x=[0:0.01:%pi*6]' ; y=[cos(x) cos(x+1*%pi/2) cos(x+2*%pi/2) cos(x+3*%pi/2)] ;
subplot(2,2,1)
subplot(2,2,2)
subplot(2,2,3)
subplot(2,2,4)
;
;
;
;
plot2d(x,y(:,1))
plot2d(x,y(:,2))
plot2d(x,y(:,3))
plot2d(x,y(:,4))
8
Chapitre 4
4.4 À partir d'une fonction
Dénition 4.4 :
L'instruction function utilisée comme ci-dessous permet de dénir une nouvelle fonction réutilisable dans toute
la suite du script SciLab :
function y=f(t)
y=mon_expression_de_la_variable_t
endfunction.
Soit x une matrice-ligne (ou matrice-colonne) et f une fonction dénie à l'aide de l'instruction function. Pour
tracer la courbe de la fonction f sur la plage d'abscisses dénies par la matrice x, deux méthodes sont possibles :
ou bien on utilise l'instruction fplot2d(x,f) (qui possède les mêmes options que plot2d) et eectue le
tracé directement,
ou bien on utilise les deux instructions y=feval(x,f), qui produit une matrice de même taille que x contenant les images par f des éléments de x, suivie de plot2d(x,y).
ou encore, lorsque l'expression de f le permet : y=f(x) ; plot2d(x,y).
4.5 Exercices
Exercice 4.1
Tracer successivement la courbe représentative des fonctions :


−2 si x < −1
f : x 7→ 2x si x ∈ [−1, 1]


2
si x > 1
sur [−3, 3]
g : x 7→
1
x
sur [−2, 0[ ∪ ]0, 2]
h : x 7→
ln(1 + e−x )
e−x
Exercice 4.2
Tracer, sur un même graphique, les courbes des fonctions :
x 7→ −e−x
x 7→ e−x
x 7→ sin(x)e−x
sur l'intervalle [0, 6π], les deux premières courbes étant en bleu, la troisième en rouge.
Exercice 4.3
Pour chaque fonction, tracer, dans une même fenêtre et les unes dessous les autres, les courbes représentatives des
fonctions f , f 0 et f 00 :
f1 : x 7→ x2 e−x
f2 (x) = √
1
1 − x2
f3 (x) = tan(x)
f4 (x) = x ln(x)
Exercice 4.4
Sur un seul et même graphique, représenter sur l'intervalle [−10, 10], les courbes des fonctions :
fσ,m : x 7→
(x−m)2
1
√ e− 2σ2
σ 2π
avec
σ∈
1
, 1, 2 et m ∈ {−3, 0, 3}
2
Exercice 4.5
Pour chaque entier n ∈ {1, 2, 5, 10, 20, 50}, tracer la courbe de la fonction exponentielle ainsi que celle de la fonction
Pn
k
fn : x 7→ k=0 xk! . Tous ces graphiques devront être dans la même fenêtre et répartis sur deux lignes.
Exercice 4.6
Tracer la fonction de répartition des lois de probabilité : B 4, 12 , B 4, 13 , U(J1, 4K) et U(J−2, 2K).
Exercice 4.7


si x < 0
0
Représenter sur un même graphique les fonctions fn : x 7→ xn si 0 6 x 6 1 sur l'intervalle [−1, 2] pour n ∈


1
si x > 1
{1, 2, 5, 10, 20, 50}. Pour tout réel x, on pose : f (x) = limn→+∞ fn (x). Représenter f sur le graphique précédent.
Exercice 4.8
(
0
Représenter sur des graphiques diérents (sur 2 lignes dans une même fenêtre) les fonction fa : x 7→ a−1 −x
x
e
sur l'intervalle [−1, 5] pour a ∈ 12 , 1, 32 , 2, 52 , 3 .
si x 6 0
si x > 0
Chapitre 5
9
Chapitre 5
Instruction conditionnelle
if ... end
5.1 Exemple
Tester le script suivant:
v=input("Nombre v de boules vertes : ")
r=input("Nombre r de boules rouges : ")
n=input("Nombre n de tirages (n<v+r) : ")
rand("seed",getdate("s")) // initialisation du hasard
urne=[v,r]
for k=1:n
tirage=floor(rand()*sum(urne))+1
if tirage<=urne(1) then urne(1)=urne(1)-1 // on ne remet pas la boule verte tirée
else urne(2)=urne(2)-1 // on ne remet pas la boule rouge tirée
end
end
disp("Nombre de boules vertes obtenues : ") ; disp(v-urne(1))
5.2 Syntaxe de l'instruction if ... end
Dénition 5.1 :
Le langage de programmation de Scilab est doté d'une instruction conditionnelle qui permet de réaliser une
ou plusieurs instructions lorsqu'une certaine condition est vraie mais qui peut aussi réaliser, au besoin, d'autre(s)
instruction(s) lorsque cette même proposition (ou condition) est fausse :
if condition then instruction ; end
ou de manière plus élégante et aérée :
if condition then // 'then' est facultatif
liste_d_instructions // peut être écrite après 'then'
end
mais aussi, dans le cas de la gestion d'une alternative :
if condition then
liste_d_instructions
else
liste_d_instructions_2
end
ou encore, lorsqu'il y a au moins trois alternatives :
if condition then
liste_d_instructions
elseif condition2 then // autant de elseif que nécessaire
else
end
Remarques :
condition est une proposition dont le programme évaluera la véracité. Lorsqu'elle s'écrit par conjonction de
plusieurs propositions, il ne faut pas hésiter à ajouter susamment de niveaux de parenthèses.
Pour faciliter la (re)lecture du code (notamment pour la recherche d'erreurs éventuelles), il est conseillé de
respecter les alignements/décalages automatiques proposés par l'éditeur SciNotes.
10
Chapitre 5
Exemple :
Modier ce script de l'exemple d'introduction pour eectuer des tirages sans remise avec b boules bleues en plus et
acher le nombre de boules obtenues pour chaque couleur.
Dénition 5.2 :
Les propositions sont écrites à l'aide :
des opérateurs de comparaison :
Maths =
6=
< >
6
>
Scilab == <> < > <= >=
des opérateurs de conjonction (par ordre décroissant de priorité, prioritaires sur les opérateurs de comparaison) :
Maths non et ou
Scilab
~
& |
Exemples :
1. Tester les deux scripts qui suivent :
// tirage d'une boule (R/V/B)
x=floor(rand()*3)+1
if x==1 then disp("rouge")
elseif x==2 then disp("bleue")
else disp("verte")
end
x=floor(rand(1,2)*3)+1 // 2 tirages
if (x(1)==x(2))&(x(1)==1) then disp("2 rouges")
elseif (x(1)==x(2))&(x(1)==2) then disp("2 bleues")
elseif (x(1)==x(2))&(x(1)==3) then disp("2 vertes")
else disp("2 couleurs distinctes")
end
2. Modier le script de l'exemple d'introduction pour tirer les boules unes par unes jusqu'à vider l'urne et :
(a) acher le nombre de tirages eectués lorsqu'il n'y a plus de boule verte dans l'urne pour la première fois.
(b) acher le nombre de tirages eectués lorsqu'il n'y a plus l'une des couleurs dans l'urne pour la première
fois.
5.3 Exercices
Exercice 5.1 (Équation du second degré)
Écrire un programme qui saisit trois réels a, b et c puis détermine et ache l'ensemble des solutions de l'équation
ax2 + bx + c = 0 dans R. Il faudra tenir compte de toutes les situations possibles (même les cas a = 0 ou encore a = 0
et b = 0).
Exercice 5.2 (Suite de Syracuse)
On considère la suite (un ) dénie par :
(
u0 ∈ N
∗
et
∀n ∈ N, un+1 =
3un + 1 si un est impair
un
si un est pair
2
1. Écrire un programme qui saisit le réel u0 et l'entier n puis calcule et ache le réel un .
2. Modier le programme pour qu'il ache ou bien le plus petit entier k ∈ J1, nK tel que uk = 1 s'il existe, ou bien
la mention pas de terme égal à 1 ! .
Remarque : Une conjecture (non démontrée à ce jour) arme que :
∀u0 ∈ N∗ , ∃k ∈ N∗ / uk = 1
(et alors on a : uk+1 = 4, uk+2 = 2, uk+3 = 1, uk+4 = 4, ...)
Exercice 5.3
On considère une succession de n lancers d'une pièce donnant pile ou face de manière équiprobable.
1. (a) Soit X le nombre de fois que l'on obtient 2 tirages consécutifs identiques. Écrire un programme qui saisit
l'entier n, eectue les tirages au sort, ache les résultats de ces tirages puis calcule et ache la valeur de la
variable aléatoire X .
(b) Soit Y le nombre de fois que l'on obtient 3 tirages consécutifs identiques. Compléter le programme précédent
an qu'il calcule et ache aussi la valeur de la variable aléatoire Y .
(c) Soit Z le rang pour lequel on obtient pour la première fois pile après deux face consécutifs ou bien deux
face après pile (ou 0 si aucune de ces deux situations ne se produit pas au cours des n tirages). Compléter
le programme précédent an qu'il calcule et ache aussi la valeur de la variable aléatoire Z .
2. Soit Xm le nombre de fois que l'on obtient m tirages consécutifs identiques. Écrire un nouveau programme qui
simule la variable aléatoire Xm après avoir demandé la valeur de l'entier m > 2.
Chapitre 6
11
Chapitre 6
Instruction itérative
while ... end
6.1 Exemple
Une urne contient b boules blanches et une boule rouge. On considère l'expérience aléatoire suivante :
tirage au sort uniforme sur l'intervalle J1, b + rK, ce qui
On eectue des tirages successifs d'une boule avec
donne le script suivant :
remise de la boule tirée entre deux tirages accompagnée
function X=experience(b)
d'une boule rouge. Le jeu s'arrête dès que l'on tire pour
r=1 ; tirage=b
la première fois une boule rouge. On note alors X le
while (tirage<=b)
numéro du dernier tirage eectué (si toutefois le jeu
tirage=floor((b+r)*rand())+1
s'arrête). On veut modéliser cette expérience aléatoire
r=r+1
par un programme dans lequel l'utilisateur se contente
end
de fournir l'entier b > 1.
X=r-1
On note r le nombre de boules rouges dans l'urne
endfunction
(r est donc initialisé à 1). La modélisation choisie ici
b=input("Nombre de boules blanches : ")
consiste à numéroter les boules blanches de 1 à b et les
rand("seed",getdate("s")) // brassage
boules rouges de b + 1 à b + r, le compteur r évoluant
disp("Nombre de tirages effectués : ")
au fur et à mesure des tirages. Ensuite, on eectue un
disp(experience(b))
L'urne contient toujours b boules blanches et une boule rouge. On modie légèrement l'expérience aléatoire :
Que calcule-t-on avec la ligne qui suit :
Entre chaque tirage, toujours en remettant la boule
B=b*ones(1:1000) ; p=mean(feval(B,experience))
tirée, on ajoute une boule verte (au lieu d'une rouge)
Commenter le graphique ci-dessous :
et les tirages cessent dès que la boule tirée n'est pas
blanche ; on ne compte plus le nombre de tirages réalisés mais on ache gagné si on termine sur une boule
verte et perdu si on termine sur la boule rouge.
Comment modéliser cette situation ?
Compléter la fonction suivante :
function gagne=experience(b)
v=0 ; tirage=b
while (______)
tirage=floor((______)*rand())+1
v=v+1
end
if ______ then gagne=0
else gagne=1
end
endfunction
6.2 Syntaxe de l'instruction while ... end
Dénition 6.1 :
Le langage de programmation de Scilab est doté d'une instruction itérative innie qui permet de réaliser une
séquence d'instructions tant qu'une certaine condition,appelée test d'arrêt, est vraie et qui s'arrête dès que cette
condition est fausse :
while condition then instruction1 ; instruction2 ; ... ; end
mais aussi :
while condition
instruction1
instruction2
...
end
12
Chapitre 6
Remarques :
condition doit pouvoir changer au cours de l'exécution de la boucle (sinon le programme est sans n).
Une telle boucle nécessite une initialisation de la variable servant au test d'arrêt puisque le test est eectué
avant la première répétition de la boucle (la boucle peut ne jamais se réaliser)
Pour faciliter la lecture du code et la recherche d'erreurs éventuelles, il est plus que souhaitable de respecter
l'indentation automatique proposée par l'éditeur SciNotes.
6.3 Exercices
Exercice 6.1 (Autre temps d'attente)
Soit n un entier naturel non nul. On considère n urnes U1 , . . . , Un , l'urne numéro k comportant k boules blanches et
n + 1 − k boules noires. On choisit une urne au hasard puis on tire successivement et avec remise une boule dans cette
urne jusqu'à obtenir pour la première fois une boule blanche.
Calculer et acher le nombre Xn de tirages eectués, l'entier n étant fourni par l'utilisateur.
Exercice 6.2 (Encore un temps d'attente)
Soit n un entier naturel non nul. On considère une urne contenant n numérotées de 1 à n. On tire successivement et
avec remise entre les tirages une boule jusqu'à obtenir pour la première fois tous les numéros possibles.
Calculer et acher le nombre Xn de tirages eectués, l'entier n étant fourni par l'utilisateur.
Exercice 6.3 (Résolution d'équation par dichotomie)
On veut résoudre l'équation f (x) = 0 par la méthode dite de dichotomie. On en rappelle le principe :
Soit ]a, b[ un intervalle contenant une unique solution x0 de l'équation f (x) = 0 pour f continue sur [a, b] (donc
f (a)f (b) < 0).
a+b
ou bien dans l'intervalle a+b
Alors la solution x0 est dans l'intervalle a, a+b
2
2 , b selon que f (a)f ( 2 ) 6 0 ou
a+b
bien que f (a)f ( 2 ) > 0. On dénit donc, par récurrence, les suites (an )n>0 et (bn )n>0 par : a0 = a, b0 = b et
pour tout entier naturel n :
an+1 =
(
an
an +bn
2
si f (an ) f
si f (an ) f
an +bn
2
an +bn
2
60
>0
(
bn+1 =
an +bn
2
bn
si f (an ) f
si f (an ) f
an +bn
2
an +bn
2
60
>0
1. Ces deux suites sont adjacentes (pourquoi ?), convergent vers x0 (pourquoi ?) et an est une approximation de
x0 à (bn − an ) près par défaut (pourquoi ?).
2. Calcule une valeur approchée à 10−k près par défaut de la solution (existe ? unique ?) de l'équation x+ln(x) = 0
dans l'intervalle [a, b], a, b, k étant fournis par l'utilisateur. Acher aussi le nombre d'itérations réalisées.
3. Résoudre l'équation tan(x) = x dans l'intervalle π2 , 3π
2 .
Exercice 6.4 (Résolution d'équation par l'algorithme de Newton)
On veut résoudre l'équation f (x) = 0 par la méthode dite de l'algorithme de Newton.
Soit I un intervalle contenant une unique solution x0 de l'équation f (x) = 0 pour f dérivable et de dérivée non
nulle sur I et a ∈ I (donc f 0 (a) 6= 0).
n)
On dénit par récurrence la suite (an )n>0 par : a0 = a et, pour tout entier naturel n, an+1 = an − ff0(a
(an ) = g(an )
pourvu que g(I) ⊂ I .
1. Montrer que, pour tout entier n, an+1 est l'abscisse du point d'intersection de l'axe des abscisses avec la tangente
à la courbe de f au point d'abscisse an . On admet que, dans des conditions adéquates, la suite (an )n>0 converge
et que sa limite est solution de l'équation f (x) = 0.
2. Calculer une valeur approchée à 10−k près de la solution de l'équation x2 − r = 0 (r > 0) dans l'intervalle
]0, +∞[, r, a, k étant fournis par l'utilisateur. Acher aussi le nombre d'itérations réalisées.
−k
−k
On admet que an est une valeur approchée de cette solution à 10
près lorsque |an+1 − an | 6 10
.
3. Résoudre l'équation x + ln(x) = 0 dans l'intervalle ]0, +∞[. Acher aussi le nombre d'itérations réalisées.
Comparer avec la méthode de la dichotomie.
Exercice 6.5 (Convergence de la série régulièrement alternée)
Déterminer une approximation à 10−k près (k fourni par l'utilisateur) de la somme de la série
(−1)n
n>0 n+1 .
P
On rappelle que les suites extraites des rangs pairs et impairs de la suite des sommes partielles sont adjacentes
.
Exercice 6.6 (Jeu du "c'est plus / c'est moins")
Écrire un programme qui choisit, au hasard, un nombre entier compris entre 1 et 100 puis propose au plus 6 essais à
l'utilisateur de deviner le nombre choisi puis répond à l'utilisateur après chacune de ses propositions de valeur par :
gagné, plus grand, plus petit. Dans le cas où l'utilisateur n'a pas deviné le nombre à l'issue des 6 essais, l'ordinateur
ache la phrase : Dommage, le nombre à deviner était ... (on ache ici la valeur exacte à deviner).
Chapitre 7
13
Chapitre 7
Calcul approché d'intégrales
7.1 Méthodes des rectangles
Théorème 7.1 (Sommes de Riemann, rappel) :
Soit f une fonction continue sur un segment [a, b]. On sait alors :
Z
a
b
n
b−a X
f (x)dx = lim
f
n→+∞
n
k=1
b−a
a+k
n
Compléter le programme suivant an qu'il calcule une valeur approchée de
fournit les données a = 0, b = 1, et successivement n ∈ {10, 100, 1000}.
Rb
a
ln(1 + x)dx lorsque l'utilisateur
function y=f(x)
y=log(1+x)
endfunction
disp("Méthode des rectangles pour le calcul dune intégrale")
a=input("Borne inférieure de lintégrale : ")
b=input("Borne supérieure de lintégrale : ")
n=input("Nombre dintervalles : ")
X=linspace(.....................)
Y=feval(.....................)
S=.....................
disp(S)
Vérier les résultats en calculant la valeur exacte de cette intégrale.
7.2 Application à la détermination d'une primitive particulière
On pose :
Z
x
Φ(x) =
−∞
et on rappelle que :
Φ (0) =
1
2
et
t2
1
√ e− 2 dt
2π
∀x ∈ R, Φ(−x) = 1 − Φ(x)
1. En s'aidant de la relation de Chasles, écrire un programme qui calcule une valeur approchée de Φ(x) pour un réel
x > 0 fourni par l'utilisateur avec des rectangles de largeur 10−k l'entier k étant aussi fourni par l'utilisateur.
2. Modier le programme pour qu'il calcule Φ(x) pour tout réel x toujours avec des rectangles de largeur 10−k .
3. Modier le programme pour tracer l'allure de la courbe de Φ sur l'intervalle [−5, 5].
7.3 Exercices
Exercice 7.1 (Méthode des trapèzes)
1. Montrer que, si f est de classe C 1 sur [a, b] et si M le maximum de f 0 sur [a, b] (ce maximum existe bien) alors :
Z
n
b
b − a M (b − a)2
b−a X
∀n ∈ N , f a+k
f (x)dx −
6
a
n
n
2n
∗
k=1
ce qui prouve bien le théorème sur les sommes de Riemann.
Remarquer que chaque fois que l'on multiplie par 10 le nombre de rectangles, la précision s'améliore d'une
décimale.
b−a
2. On note ak = a + k b−a
n pour tout k ∈ J0, nK. On remplace maintenant le rectangle de largeur n et de hauteur
f (ak ) par le trapèze déni par les points (ak−1 , 0), (ak−1 , f (ak−1 )), (ak , f (ak )) et (ak , 0).
Montrer que la somme est aires des n trapèzes est :
"
#
n−1
b − a f (a) X
f (b)
+
f (ak ) +
Sn =
n
2
2
k=1
14
Chapitre 7
En déduire que : Sn −−−−−→
n→+∞
Rb
a
f (x)dx.
3. Écrire un programme qui calcule la valeur approchée de
fournis par l'utilisateur.
Rb
a
ln(1 + x)dx par cette méthode ; a, b et n étant
Exercice 7.2 (Interpolation de degré 2)
Dans la méthode précédente on remplace l'approximation ane de f pour obtenir un rectangle par une approximation
parabolique. Autrement dit, sur chaque intervalle [ak−1 , ak ] (toujours avec ak − ak−1 = b−a
n ), on va remplacer la
fonction f par le polynôme Pk = αk X 2 + βk X + γk de sorte que, en notant ak− 21 le milieu de [ak−1 , ak ] (c'est-à-dire
que ak− 21 = ak−12+ak ), on a :


Pk (ak−1 ) = f (ak−1 )
Pk (ak− 21 ) = f (ak− 21 )


Pk (ak )
= f (ak )
et ainsi :
b
Z
f (t)dt ≈
a
n Z
X
k=1
ak
Pk (t)dt = In (f )
ak−1
1. Vérier que la somme In (f ) approchant l'intégrale vaut :
In (f ) =
n X
a2 − a2k−1
a1 − a1k−1
a3 − a3k−1
+ βk k
+ γk k
αk k
3
2
1
k=1
2. Montrer que :
   2
ak−1
αk
2
∀k ∈ J1, nK,  βk  = ak− 21
γk
a2k
ak−1
ak− 21
ak

−1 
1
f (ak−1 )
1 f (ak− 1 )
2
f (ak )
1
3. À l'aide des instructions matricielles, écrire un programme qui calcule la valeur approchée de
par cette méthode, les réels a, b et l'entier n étant fournis par l'utilisateur.
4. de Pk , montrer que
R ak
ak−1
Pk (t)dt =
b−a
n
×
f (ak−1 )+4f ak− 1 +f (ak )
2
6
Rb
a
ln(1 + x)dx
.
Chapitre 8
15
Chapitre 8
Variables aléatoires : simulations et
représentations graphiques
8.1 Simulation de variables discrètes à valeurs entières
Dénition 8.1 (Rappels) :
rand() est une fonction : elle fournit un résultat choisit au hasard dans l'intervalle [0, 1[. Ce résultat doit
être stocké ou aché ou utilisé d'une façon quelconque.
Si m et n sont deux entiers, rand(m,n) fournit une matrice à m lignes et n colonnes dont chacun élément est
choisi au hasard dans [0, 1[.
Si x est une matrice, rand(x) fournit une matrice ayant le même nombre de lignes et le même nombre de
colonnes que x et dont chaque élément est choisi au hasard dans [0, 1[.
L'instruction rand("seed",getdate("s")) permet d'initialiser le générateur de nombres aléatoires.
Théorème 8.1 (Lois discrètes usuelles) :
Loi uniforme U(Ja, bK) : X=a+floor((b-a+1)*rand())
Loi binomiale B(n, p) : X=0 ; for k=1:n ; if rand()<p ; X=X+1 ; end ; end
Loi géométrique G(p) : X=1 ; while rand()>p ; X=X+1 ; end
Remarque :
Pour la loi de Poisson, il n'y a pas de modèle expérimental donc une possibilité consiste à utiliser l'approximation
P(λ) ≈ B n, nλ pour n assez grand .
Dénition 8.2 (Représentations graphiques de plusieurs répétitions) :
L'instruction bar(x,y) représente le diagramme en rectangles des éléments de la matrice-ligne y (en ordonnée)
en fonction des éléments de la matrice-ligne x (en abscisse). Les matrices x et y doivent avoir le même nombre
de colonnes. Comme pour les représentations graphiques de fonctions, il est possible de représenter côte à côte
plusieurs rectangles pour une même abscisse : pour ce faire, x doit être une matrice-colonne et y une matrice
ayant le même nombre de lignes que x.
L'instruction histplot(x,y) représente l'histogramme des fréquences d'apparition des éléments de la matrice
x (rangés dans l'ordre strictement croissant ) parmi les éléments de la matrice y . Les matrices-lignes x et y
n'ont pas nécessairement le même nombre de lignes et/ou de colonnes mais les éléments de la matrice y sont,
en principe, ceux de la matrice x, certains apparaissant plusieurs fois dans y .
Exemple :
Tester le script suivant :
a=input("a=") ; b=input("b=")
x=[1:20]' ; X=a+floor((b-a+1)*rand(x)) ; Y=a+floor((b-a+1)*rand(x))
subplot(1,2,1) ; bar(x,[X,Y])
subplot(1,2,2) ; histplot([a-0.5:b+0.5]',X,2) ; histplot([a-0.5:b+0.5]',Y,3)
8.2 Fonction de répartition
Dénition 8.3 :
Soit X une matrice-ligne. L'instruction M=tabul(X,"i") donne une matrice une matrice à 2 colonnes dont la
colonne 1 contient la liste des valeurs deux à deux distinctes du tableau X rangées dans l'ordre croissant ("i"
pour increasing, pour l'ordre décroissant c'est "d" pour decreasing ) et dont la colonne 2 contient le nombre
d'apparitions de valeur correspondante dans la première ligne dans le tableaux initial X.
Soit X une matrice-ligne. L'instruction S=cumsum(X) donne une matrice de même format que X de sorte que le
terme de rang i de S est la somme des termes de rang 1 à i de X.
Exemples :
X=[1,2,2,2,1,1,2,1,1] ; M=tabul(X,"i") donne M=[1,5;2,4].
S=cumsum([1,2,3,4,5]) donne S=[1,3,6,10,15].
16
Chapitre 8
Théorème 8.2 :
Soit X une variable aléatoire dont on possède m réalisations stockées dans un tableau X.
On récupère la liste des valeurs xi de la variable X ainsi que les probabilités pi de la façon suivante :
XP=tabul(X,"i") // ligne 1 -> X(Omega) ; ligne 2 -> les effectifs associés
Xi=XP(:,1) ; Pi=XP(:,2)/m ; Fi=cumsum(Pi) // Fi -> les fréquences cumulées des Xi
Pour une variable discrète, on trace une fonction en escalier :
k=length(Xi) ; ecart=(Xi(k)-Xi(1))/(k/2) // c'est un choix
for i=1:k-1 ; plot2d([Xi(i),Xi(i+1)],[Fi(i),Fi(i)],5) ; end
plot2d([Xi(1)-ecart,Xi(1)],[0,0],5) ; plot2d([Xi(k),Xi(k)+ecart],[1,1],5)
Pour une variable à densité, on trace une fonction ane par morceaux :
k=length(Xi) ; ecart=(Xi(k)-Xi(1))/(k/2)
plot2d([Xi(1)-ecart,Xi(1)],[0,Fi(1)],5) ; plot2d([Xi(k),Xi(k)+ecart],[Fi(k),1],5)
Exemple (Loi et répartition de la loi binomiale B(n, p)) :
n=input("n = ") ; p=input("p = ") ; m=100000 ; X=zeros(m,1)
for i=1:m ; for k=1:n ; if rand()<p ; X(i)=X(i)+1 ; end ; end ; end
F=tabul(X,"i") ; Xi=F(:,1) ; Pi=F(:,2)/m ; Fi=cumsum(Pi)
subplot(1,2,1) ; bar(Xi,Pi) // loi de probabilité
k=length(Xi) ; ecart=(Xi(k)-Xi(1))/(k/2) ; subplot(1,2,2)
plot2d([Xi(1)-ecart,Xi(1)],[0,0],5) ; plot2d([Xi(k),Xi(k)+ecart],[1,1],5)
Remarque :
Si on possède déjà la loi de probabilité, on trace la répartition en passant directement au deuxième ou troisième point.
8.3 Exercices
Exercice 8.1
On lance un dé non truqué à 6 faces numérotées de 1 à 6. Lorsque le dé donne le résultat k ∈ J1, 6K, on lance alors une
pièce non truquée k fois et on appelle X le nombre de côtés pile obtenus.
1. Écrire, sous la forme d'une fonction, un script simulant la variable aléatoire X .
2. On réalise 10000 fois cette expérience aléatoire.
(a) Quel est l'ensemble X(Ω) ? Représenter l'histogramme des fréquences d'apparition des éléments de X(Ω).
(b) Représenter la fonction de répartition de la variable aléatoire X .
(c) Calculer une estimation de la valeur de l'espérance E(X) de X .
3. On suppose désormais que le nombre de faces du dé est n.
(a) Pour n ∈ {2, 6, 10, 20, 50, 100}, calculer une estimation de E(X).
(b) Représenter graphiquement ces résultats et proposer une expression de E(X) en fonction de l'entier n.
Exercice 8.2
Une urne contient r boules rouges et b boules bleues. On tire successivement et sans remise n boules dans cette urne
(n ∈ J1, r + bK). On note X le nombre de rouges obtenues.
1. Écrire un script achant le diagramme de la loi de probabilité et la fonction de répartition de la variable X .
2. Les entiers r et b étant xés, représenter E(X) en fonction de n. Proposer une expression de E(X).
Exercice 8.3
À l'entrée d'un restaurant, n personnes conent leur chapeau respectif (tous deux à deux distincts) à la réception. À
la sortie, le réceptionniste, très joueur, décide de les rendre au hasard (cf 10.2). On note Xn la variable aléatoire égale
au nombre de personnes qui ont obtenu leur propre chapeau.
1. Écrire un script achant le diagramme de la loi de probabilité et la fonction de répartition de la variable Xn .
2. Représenter E(Xn ) en fonction de n. Proposer une expression de E(Xn ).
Exercice 8.4
On lance n fois consécutivement un dé non truqué possédant s faces numérotées de 1 à s. On note Xs,n le nombre de
faces qui ne sont jamais apparues au cours de ces n lancers.
1. Simuler la variable aléatoire Xs,n (utiliser l'instruction find) lorsque s = 6 et n = 4 puis n = 10 et enn n = 40.
2. On réalise m = 10000 répétitions de cette expérience aléatoire lorsque s = 10 et n = 50.
(a) Représenter l'histogramme des fréquences d'apparitions des valeurs prises par Xs,n .
(b) Représenter la fonction de répartition de Xs,n .
3. Que se passe-t-il lorsque n tend vers l'inni (s étant xé) ?
Chapitre 9
17
Chapitre 9
Algèbre linéaire
9.1 Fonctions matricielles algébriques
Dénition 9.1 :
(rappel ) Rang d'une matrice A : rank(A).
(rappel ) Inverse, lorsqu'il existe, d'une matrice A : inv(A) ou A^(-1).
Noyau d'une matrice : kernel(A) (les colonnes de la matrice donnée en réponse forment une base orthonormale
du noyau).
Résolution d'un système linéaire AX + B = 0 : [X0,KerA]=linsolve(A,B) (X0 est une solution particulière et
KerA est le noyau de A donc les solutions du système sont de la forme X0 + K avec K ∈ KerA).
Exemples :
1. Soit A ∈ Mn,p (R)). Comparer les noyaux de A et de tAA dans diérents cas. Comparer les rangs de tAA et de
AtA dans diérents cas.
2. Écrire un script SciLab qui ache deux solutions distinctes du système puis une solution du système sous la
ou les contraintes fournies :
(
x+y+z
=1
; contrainte : y = 8.
(a)
x − y − 3z = 2
(
2x − y + 3z − 4t
=0
(b)
; contraintes : y = −6 et z = 9.
−x + 2y − 4z + 3t = 1
9.2 Exercices
Exercice 9.1
1. Soit ( #„
x 1 , . . . , #„
x p ) une famille de vecteurs donnés de Rn . Écrire un script permettant d'extraire de cette famille
une base du sous-espace vectoriel qu'il engendre (on pourra regrouper ces vecteurs dans une matrice A ∈
Mn,p (R)).
2. Déterminer une base de Im(f ) dans les cas suivants :
 
x
x + 2y + 3z
f : y  7→
4x + 4y + 6z
z

 

2x − y − z
x
f : y  7→ −x + 2y − z 
z
−x − y + 2z


x + 4y
x
f:
7→ 2x + 5y 
y
3x + 6z
 


x
x − 2y + 3z − 2t
y 



f: 
 z  7→ −x + 2y + 2z − 3t
2x − 4y + z + t
t
Exercice 9.2 (Pivot de Gauss)
1. Expliquer pourquoi le script suivant détermine une matrice réduite de la matrice A initiale :
A=[1,1,1 ; 2,3,4 ; 5,6,7] ; disp(A)
[n,p]=size(A) ; i=0 ; j=0
while j<p
i=i+1 ; pivot=0
while (pivot==0)&(j<p) // recherche du plus "grand" pivot non nul pour la ligne i
j=j+1
for k=i+1:n
if abs(A(i,j))<abs(A(k,j)) then C=A(i,:) ; A(i,:)=A(k,:) ; A(k,:)=C ; end
end
pivot=A(i,j)
end
if pivot<>0 then // réduction avec l'aide de la ligne i
for k=i+1:n do A(k,:)=A(k,:)-A(k,i)/pivot*A(i,:) ; end
end
end
disp(A)
18
Chapitre 9
2. Déterminer le rang de la matrice proposée puis son noyau. Comparer avec le résultat de la réduction obtenue.
Exercice 9.3
Soit A ∈ Mn,p (R) et B ∈ Mn,1 (R). On souhaite résoudre le système linéaire AX = B dans Mp,1 (R).
1. (a) Écrire un script qui résout le système en utilisant la fonction inv lorsque cela est possible et linsolve sinon.
(b) Application à la résolution de :
(
x+y+z
x−y+z


x + y + z
x + 2y + 3z


x + 4y + 9z
=1
=2
=1
=2
=3


−2x + y + z
x − 2y + z


x + y − 2z
=1
=2
=3


x + y
2x − y


3x + 2y
=1
=3
=0
2. On admet le résultat suivant (programme d'algèbre ECS2) :
si A ∈ Mn,p (R) est de rang p (donc n > p), si
B ∈ Mn,1 (R) et si le système AX = B n'admet pas de solution dans Rp alors la matrice tAA est inversible et
t
t
le système AAX = AB admet une unique solution X0 appelée meilleure approximation du système AX = B
au sens des moindres carrés : kAX0 − Bk < kAX − Bk pour tout X 6= X0 élément de Mp,1 (R).
Modier le script précédent pour donner cette meilleure approximation le cas échéant. Tester.
Exercice 9.4

1
1

.
1. Construire la matrice A = 
 ..

1
1
1
1
(0)
1
...
..
1
(0)
.
...
1
1

1
1

.. 
∈ Mn (R) pour n = 10.
.

1
1
2. Déterminer son rang. Est-elle inversible ?
3. Déterminer son noyau. Que dire du résultat proposé ? Le déterminer à la main.
Chapitre 10
19
Chapitre 10
Lois de probabilité
10.1 Fonction grand
Dénition 10.1 :
La fonction grand permet de simuler des lois de probabilités usuelles, aussi bien celles au programme de première
année que celles au programme de seconde année. Ainsi :
Y=grand(nombre_lignes,nombre_colonnes,"nom_loi",paramètre(s)) permet de créer une matrice Y de
taille (m, n) dont les éléments sont des valeurs prises de la loi de probabilité choisie.
ou bien Y=grand(X,"nom_loi",paramètre(s)) avec X matrice dont la taille déjà connue permet de créer une
matrice Y de même taille que X dont les éléments sont des valeurs prises de la loi de probabilité choisie.
Les lois discrètes usuelles sont :
loi uniforme U(Ja, bK) : grand(lig,col,"uin",a,b),
loi binomiale B(N, p) : grand(lig,col,"bin",N,p),
loi géométrique G(p) : grand(lig,col,"geom",p),
loi de Poisson P(λ) : grand(lig,col,"poi",lambda).
Les lois à densité usuelles sont :
loi uniforme U([a, b]) : grand(lig,col,"unf",a,b),
loi exponentielle E(λ) : grand(lig,col,"exp",1/lambda),
loi normale N (m, σ 2 ) : grand(lig,col,"nor",m,sigma).
Remarque :
L'instruction grand(lig,col,"uin",a,b) remplace donc l'instruction floor((b-a)*rand(lig,col)+a). Elle semble
même plus aléatoire .
10.2 Exercices
Exercice 10.1 (Temps d'attente du ke pile)
1. Écrire un programme qui simule l'expérience aléatoire dont le résultat est le temps d'attente du ke pile lors de
lancers successifs d'une pièce truquée de sorte que le côté pile apparaît avec la probabilité p (l'entier k et le réel
p étant fournis par l'utilisateur).
2. On réalise 10000 fois cette expérience. Calculer une valeur approchée du nombre moyen de lancers réalisé à
chaque expérience.
Exercice 10.2
On considère une pièce truquée de sorte que le côté pile apparaît avec la probabilité p. On eectue des lancers jusqu'à
obtenir une première fois le côté pile. X étant le nombre de lancers réalisés, on eectue ensuite X nouveaux lancers et
on compte le nombre Y de pile obtenus au cours de cette nouvelle séquence de lancers.
1. Écrire un programme qui simule la variable aléatoire Y (le réel p étant fourni par l'utilisateur).
2. Calculer une valeur approchée de l'espérance de Y .
Exercice 10.3
Soit X ,→ P(λ) où λ est un réel strictement positif donné. Soit a un réel strictement positif.
1. Que fait l'instruction Scilab suivante : X=grand(1,10000,"poi",3) ?
2. Écrire une instruction Scilab calculant une valeur approchée de P (X > a) en utilisant les données du tableau
X qui précède pour tout a ∈ J1, 10K.
3. Comparer ces estimations de P (X > a) avec la valeur correspondante de
Markov ?
4. Évaluer la qualité de l'inégalité de Bienaymé-Tchebychev.
E(X)
a .
Que dire de l'inégalité de
Exercice 10.4
Soit λ un réel strictement positif. Soit n un entier naturel strictement supérieur à λ.
1. Construire une matrice-ligne à n colonnes ne comportant que des 0 ou des 1 choisis au hasard de sorte que
chaque coecient vaut 1 avec la probabilité nλ .
Justier que la somme des coecients de cette matrice suit la loi B n, nλ .
20
Chapitre 10
2. Construire une matrice A à 1000 lignes et n colonnes sur le même principe. Construire la matrice-colonne B
dont le coecient de la ligne i est égal au nombre de 1 dans la ligne i de la matrice A.
3. Représenter l'histogramme des valeurs de la matrice B . Tester pour λ = 5 et n ∈ {20; 50; 100}. Qu'a-t-on
représenté lorsque n est grand ?
Exercice 10.5 (Convergence en loi)
Soit λ un réel strictement positif. Dans un espace probabilisé (Ω, T , P), on considère une variable aléatoire X de loi
P(λ) et, pour tout entier n > λ, une variable aléatoire Xn de loi B n, nλ .
1. On considère le script suivant que l'on testera avec λ = 1, λ = 2 et λ = 3 :
lambda=input("Donner un réel lambda >0 : ")
N=10000 ; xmax=floor(4*lambda)
X=grand(N,1,"poi",lambda)
for k=1:6
n=(floor(lambda+1))*3^(k-1)
Xn=grand(N,1,"bin",n,lambda/n)
subplot(2,3,k) ; histplot([-0.5:xmax+0.5],Xn,2) ; histplot([-0.5:xmax+0.5],X,5)
end
2. Interpréter ce script. Quel théorème du cours de mathématiques illustre-t-il ?
Exercice 10.6 (Une expérience aléatoire)
À l'entrée d'un restaurant, n personnes conent leur chapeau respectif (tous deux à deux distincts) à la réception. À
la sortie, le réceptionniste, très joueur, décide de les rendre au hasard. Modéliser cette expérience aléatoire et donner
la liste des personnes qui ont obtenu leur propre chapeau. On peut procéder de la façon suivante :
On crée un tableau E à une seule ligne contenant initialement les entiers de 1 à n (les numéros des chapeaux
dans l'ordre de leur dépôt à la réception) et qui contiendra, au fur et à mesure, les numéros (toujours dans
l'ordre croissant) des chapeaux non encore distribués.
On tire au sort successivement et sans remise tous les numéros.
Au fur et à mesure des tirages, on complète un tableau S à une seule ligne qui contiendra les numéros des
chapeaux dans l'ordre de leurs tirages. À chaque instant, la concaténation des tableaux E et S doit donner tous
les numéros.
Une fois tous les tirages eectués, le chapeau i est à son propriétaire si et seulement si S(i) = i ou encore
S(i) − i = 0.
Tester ainsi le script qui suit :
n=input("Donner n : ")
E=[1:n] ; S=[] // initialisation des tableaux
for i=1:n // mise en place des répétitions
k=grand(1,1,"uin",1,length(E)) // tirage au sort du numéro de case de E
S=[S,E(k)] // on ajoute le numéro de chapeau à la liste S
E=[E(1:k-1),E(k+1:length(E))] // on enlève de la liste E le numéro en question
end
disp(S) // affichage du résultat
X=find(S-[1:n]==0) // recherche des rangs des cases nulles de S-[1:n]
disp(X) // affichage des numéros des personnes ayant leur propre chapeau
Question subsidiaire : Sur 10000 réalisations de cette expérience aléatoire, calculer le nombre moyen de personnes
qui obtiennent leur propre chapeau.
Exercice 10.7
Lorsque n, p, a, b sont des entiers (non nuls pour n et p), l'instruction grand(n,p,"uin",a,b) produit une matrice à
n lignes et p colonnes dont les coecients sont les résultats de tirages au sort uniforme sur les entiers de a à b.
1. On lance deux dés cubiques non truqués dont les faces sont numérotées de 1 à 6.
(a) Construire un tableau à deux colonnes simulant les réalisations de n (fourni par l'utilisateur) lancers de ces
deux dés.
(b) Construire le tableau des sommes de ces deux dés pour chacun des n lancers.
(c) Construire et acher le tableau des fréquences observées de ces sommes.
(d) Déterminer et acher la somme la plus fréquente. Était-ce prévisible ?
2. Même question avec k dés (k > 2) ayant chacun p faces numérotées de 1 à p.

ECS1 : Initiation à SciLab

Transcription

Documents pareils

INVERSE D`UNE MATRICE

construire son plan d`action commercial pour

TP3 Scilab - Structures alternatives et itératives

Lycée Stendhal (Grenoble) Classe de première ES Option Maths

Mathématiques Appliquées L2, 2007

Université My Ismail ESTK -Khénifra. A.U:2016

Programmer avec Scilab

TD1 : Matrices et corrélations

I Sim City II Matrice de transition

TP1 : Etablir des liens de parenté entre les espèces. Partie 1