Tous les calculs effectués par Scilab sont numériques.

Scilab calcule avec des matrices (voir le chapitre IIChapitre 2 - Programmer).

Les opérations se notent « + » pour l'addition, « - » pour la soustraction, « * » pour la multiplication, « / » pour la division, « ^ » pour les exposants. la virgule des nombres décimaux est notée avec un point. Par exemple :

-->2+3.4
ans =
    5.4

Il est nécessaire de bien respecter la casse (majuscules et minuscules) pour que les calculs s'effectuent correctement. Par exemple, avec la commande sqrt qui permet de calculer la racine carrée :

-->sqrt(9)
ans =
    3.

alors que :

-->SQRT(9)
    !--error 4
Variable non définie: SQRT

Des nombres particuliers

%e et %pi représentent respectivement e et π :

%i représente la variable complexe i en entrée et s'affiche i en sortie :

-->2+3*%i
ans =
    2. + 3.i

Pour ne pas afficher le résultat

En ajoutant un point virgule « ; » à la fin d'une ligne de commande, le calcul s'effectue mais le résultat ne s'affiche pas.

-->(1+sqrt(5))/2;

-->(1+sqrt(5))/2
ans =
    1.6180339887499

Pour se rappeler le nom d'une fonction

Les noms des principales fonctions sont récapitulés au chapitre 4 de ce livret (Exemple 48Exemple 48).

Par exemple :

-->exp(10)/factorielle(10)
ans =
    0.0060699034928

Il est possible d'utiliser la touche tabulation →│ de son clavier, pour compléter le nom d'une fonction ou d'une variable dont on a donné les premières lettres.

Par exemple, si l'on tape dans la console :

-->fact

Et que l'on tape sur la touche tabulation, une petite fenêtre apparaît permettant de choisir entre toutes les fonctions et noms de variables commençant par fact, comme factorielle et factorise. Il suffit alors de double-cliquer sur la fonction souhaitée ou de la sélectionner avec la souris ou avec les flèches du clavier ↑ ↓ et d'appuyer sur la touche Entrée (Windows et linux) ou Retour (Mac OS X) pour l'insérer.

Vous serez amené à utiliser tout particulièrement les menus listés ci-dessous.

Applications

• L'historique des commandes permet de retrouver toutes les commandes des sessions précédentes et de la session courante.
• Le navigateur de variables permet de retrouver toutes les variables utilisées précédemment au cours de la même session.

Édition

Préférences (dans le menu Scilab sous Mac OS X) permet de régler et de personnaliser les couleurs, les polices et la taille des caractères dans la console et dans l'éditeur, ce qui est très utile quand on projette sur un écran devant une classe.

Cliquez sur Effacer la console pour effacer tout le contenu de la console. Dans ce cas, l'historique est conservé et les calculs effectués lors de la session restent en mémoire. Vous pourrez toujours revenir sur une commande qui a été effacée en utilisant les flèches du clavier.

Contrôle

Pour interrompre un programme en cours d'exécution, on peut :

• taper pause dans le programme ou cliquer sur Contrôle > Interrompre dans la barre de menus (Ctrl X sous Windows et Linux ou Commande X sous Mac OS X), si le programme est déjà lancé. Dans tous les cas, l'invite de commande « --> » se transformera en « -1-> », puis en « -2-> »…, si l'opération est répétée ;
• pour revenir au moment de l'interruption du programme, taper resume dans la console ou cliquer sur Contrôle > Reprendre ;
• pour arrêter définitivement un calcul sans possibilité de retour, taper abort dans la console ou cliquer sur Contrôle > Abandonner dans la barre de menus.

Lycée

À partir du menu lycée, deux applications vous sont proposées pour illustrer votre cours en classe :

• ajustement affine par la méthode des moindres carrés,
• calcul d'aire pour l'encadrement de l'aire du domaine compris entre une courbe et l'axe des abscisses par la méthode des rectangles.

Pour ouvrir l'éditeur à partir de la console, cliquez sur la première icône dans la barre d'outils ou sur Applications > SciNotes dans la barre de menus.

L'éditeur s'ouvre avec un fichier par défaut qui s'intitule « Sans titre 1 ».

On tape du texte dans l'éditeur comme dans n'importe quel traitement de texte.

Dans l'éditeur de texte, l'apparition des parenthèses, ouvrantes et fermantes et des commandes de fin de boucle, de fonction et de test est automatique.

On peut cependant désactiver ces deux fonctionnalités dans le menu Options > Complétion automatique, en cliquant sur les deux entrées ci-dessous activées par défaut :

• (,[,…
• if,function,…

En principe, il faut aller à la ligne après chaque instruction, mais il est possible de taper plusieurs instructions sur une même ligne en les séparant par un point virgule « ; ».

Un décalage de début de ligne appelé indentation se fait automatiquement lorsqu'on commence une boucle ou un test.

Dans l'exemple suivant, on calcule 10 termes de la suite (kitxmlcodeinlinelatexdvpu_{n}finkitxmlcodeinlinelatexdvp) définie par : kitxmlcodeinlinelatexdvp\left\{ \begin{aligned} &u_{1}=1\\ &u_{n+1}=2u_{n}-3 \end{aligned} \right.finkitxmlcodeinlinelatexdvp

Il est possible d'enregistrer tout fichier en cliquant sur Fichier > Enregistrer sous.

L'extension « .sce » à la fin du nom de fichier déclenchera automatiquement le lancement de Scilab à l'ouverture du fichier (excepté sous linux et Mac OS X).

En cliquant sur Exécuter dans la barre de menus, trois options sont proposées :

• exécuter « …fichier sans écho » (Ctrl maj e sous Windows et linux, Cmd maj e sous Mac OS X) : le fichier est exécuté sans que le programme ne s'écrive dans la console (en ayant enregistré le fichier au préalable).
• exécuter « …fichier avec écho » (Ctrl l sous Windows et linux, Cmd l sous Mac OS X) : réécrit le fichier dans la console et l'exécute.
• exécuter « …jusqu'au curseur, avec écho » (Ctrl e sous Windows et linux, Cmd e sous Mac OS X) : réécrit la sélection choisie avec la souris dans la console et l'exécute ou exécute les données du fichier jusqu'à la position du curseur définie par l'utilisateur).

On peut aussi utiliser le copier / coller classique.

Une fenêtre graphique s'ouvre pour tout tracé.

il est possible de tracer des courbes, des surfaces, des nuages de points, des histogrammes (voir le chapitre IIChapitre 2 - Programmer).

On obtient un exemple de courbe en tapant dans la console :

-->plot

La loupe permet de faire un zoom. Pour effectuer un zoom en deux dimensions, cliquez sur l'icône et avec la souris créez un rectangle qui constituera la nouvelle vue agrandie. Pour effectuer un zoom en trois dimensions, cliquez sur l'icône et créez le parallélépipède qui constituera la nouvelle vue agrandie. Il est également possible de zoomer en utilisant la molette de la souris.

Pour revenir à l'écran initial, cliquez sur l'autre loupe .

L'icône permet de faire tourner la figure (particulièrement utile en 3d) avec des actions de clic droit qui seront guidées par des messages en bas de la fenêtre graphique.

Pour faire apparaître un quadrillage, tapez dans la console quadrillage.

Pour des modifications plus précises, cliquez sur Édition > Propriétés de la figure ou Propriétés des axes et laissez-vous guider (cette option n'est pas encore disponible sous Mac OS X).

Scilab n'est pas un logiciel de calcul formel. il calcule uniquement avec des nombres. Tous les calculs sont en réalité faits avec des matrices, mais cela peut passer inaperçu. bien que la notion de matrice ne soit pas connue dans la plupart des classes de lycées, on utilise les vecteurs et les suites de nombres qui sont, en fait, des matrices 1 × n ou n × 1, de même qu'un nombre est une matrice de dimension 1 × 1.

Les variables n'ont pas besoin d'être déclarées à l'avance, mais toute variable doit avoir une valeur.

Par exemple, demander la valeur de la variable a sans lui avoir donné de valeur auparavant, produit une erreur :

-->a
    !--error 4
Variable non définie : a

si l'on affecte une valeur à la variable a, il n'y a plus d'erreur :

-->a=%pi/4
a =
    0.7853981633974
-->a
a =
    0.7853981633974

On peut utiliser n'importe quel nom de variable qui n'est pas déjà défini par le système :

-->Pisur2=%pi/2
Pisur2 =
    1.5707963267949

Si l'on n'affecte pas le résultat d'un calcul à une variable, la valeur sera affectée automatiquement à la variable appelée ans :

-->3*(4-2)
ans =
    6.
-->ans
ans =
    6.

Les fonctions sont le moyen le plus simple et le plus naturel pour faire des calculs à partir de variables et

Obtenir des résultats à partir de celles-ci.

La définition d'une fonction commence par function et finit par endfunction. Par exemple, pour transformer des euros (e) en dollars (d) avec un taux de change (t), définissons la fonction dollars. Les variables sont e et t et l'image est d.

-->function d=dollars(e,t); d=e*t; endfunction
-->dollars(200,1.4)
ans =
    280.

Le plus souvent, on utilise au lycée des fonctions numériques à une variable réelle. Par exemple, deux fonctions f et g sont définies à l'aide des commandes ci-dessous :

-->function y=f(x); y=36/(8+exp(-x)); endfunction
-->function y=g(x); y=4*x/9+4; endfunction

Les fonctions ayant été définies, elles peuvent être utilisées pour calculer des valeurs :

-->f(10)
ans =
    4.4999744626844
-->g(12.5)
ans =
    9.5555555555556

L'affectation se fait de façon simple avec le symbole « = ».

Pour demander avec une phrase la valeur à attribuer à une variable, on utilise input, en mettant la phrase entre des guillemets droits « "" ».

Reprenons l'exemple du calcul des dollars à partir d'euros :

e=input("Somme en euros : ");
t=input("Taux de change : ");
d=e*t;
afficher("Somme en dollars : "+string(d))

Somme en euros : 200
Taux de change : 1.4

Somme en dollars : 280

Avec input, le programme attend une valeur.

Pour exécuter correctement le programme, enregistrez-le puis cliquez sur Exécuter > …fichier sans écho dans la barre de menus. Renseignez alors dans la console, les valeurs au fur et à mesure qu'elles vous sont demandées (dans l'exemple, on a tapé 200, entrée, puis 1.4, entrée).

si vous cliquez sur Exécuter > …fichier avec écho ou sur Exécuter > …jusqu'au curseur, avec écho, ou lors d'un copier / coller, vous obtiendrez une erreur car le programme étant recopié, la valeur attendue pour e sera t, qui n'est pas un nombre.

Écrire

Taper le nom d'une variable affiche sa valeur, sauf avec « ; » en fin de commande.

Les crochets

Les crochets permettent de définir des matricesL'arithmétique.

Comme énoncé précédemment, le calcul matriciel est à la base des calculs effectués dans Scilab.

Un espace ou une virgule permet de passer d'une colonne à la suivante et un point virgule, d'une ligne à l'autre.

Pour définir un vecteur colonne et obtenir un affichage en colonne :

-->v=[3;-2;5]
v =
    3.
- 2.
    5.

Pour définir un vecteur ligne et obtenir un affichage en ligne :

-->v=[3,-2,5]
v =
    3.    - 2.    5.

Pour définir une matrice et afficher un tableau :

-->m=[1 2 3;4 5 6;7 8 9]
m =
    1.    2.    3.
    4.    5.    6.
    7.    8.    9.

La fonction afficher

afficher est le nom francisé de la fonction disp utilisée dans Scilab sans le module lycée. elle est toujours suivie de parenthèses.

Avec le vecteur v précédent :

-->v(2)
ans =
- 2.
-->afficher(v(2))
- 2.

Pour afficher une chaîne de caractères (en général une phrase), on la met entre guillemets :

-->afficher("Bob a gagné")
Bob a gagné

Pour mélanger des mots et des valeurs, utilisez la commande string qui transforme les valeurs en caractères, et « + » entre les différentes parties :

-->d=500;
-->afficher("Bob a gagné "+string(d)+" dollars")
Bob a gagné 500 dollars

Si la phrase contient une apostrophe, il est nécessaire de la doubler dans la chaîne de caractères pour qu'elle s'affiche correctement :

-->afficher("C''est juste")
C'est juste

L'opérateur « : » permet de définir des vecteurs de nombres dont les coordonnées sont en suite arithmétique. On donne « la première valeur : le pas : la dernière valeur » (pas forcément atteinte). Si le pas n'est pas mentionné, sa valeur est 1 par défaut.

Par exemple, pour définir un vecteur ligne d'entiers qui s'incrémentent de 1 entre 3 et 10 :

-->3:10
ans =
    3.    4.    5.    6.    7.    8.    9.    10.

ou qui s'incrémentent de 2 entre 1 et 10 :

-->1:2:10
ans =
    1.    3.    5.    7.    9.

ou qui se décrémentent de 4 entre 20 et 2 :

-->u=20:-4:2
u =
    20.    16.    12.    8.    4.

La structure de boucle la plus simple pour un nombre connu d'itérations s'écrit avec for … end qui signifie « Pour … fin de pour ».

Exemple : Calcul de 20 termes d'une suite définie par récurrence par : kitxmlcodeinlinelatexdvpU_{1}=4\mathrm{\ et\ }u_{n+1}\:=\:u_{n}+2n+3finkitxmlcodeinlinelatexdvp

u(1)=4;
for n=1:20
    u(n+1)= u(n)+2*n+3;
    afficher([n,u(n)])
end

Si l'on veut que la boucle s'arrête lorsqu'un objectif donné est atteint, on utilisera la forme while … end qui signifie « Tant que … fin de tant que ».

Exemple : J'ai replanté en 2005 un sapin de noël qui mesurait 1,20 m. il grandit de 30 cm par an. J'ai décidé de le couper quand il dépasserait 7 m. En quelle année vais-je couper mon sapin ?

h=1.2;
a=2005;
while h<7
    h=h+0.3;
    a=a+1;
end
afficher("Je couperai mon..
sapin en "+string(a))

Comparer des nombres ou vérifier si une affirmation est vraie ou fausse sont des tests utiles. Voici les commandes correspondantes :

Lorsque l'on veut comparer deux vecteurs (ou deux matrices), les tests « == » et « <> » comparent terme à terme. Par exemple :

-->X=[1,2,5]; Y=[5,3,5];
-->X==Y
ans =
    F F T

Pour tester si les vecteurs sont égaux, on utilise isequal, et s'ils sont différents, ~isequal :

-->isequal(X,Y)
ans =
    F
-->~isequal(X,Y)
ans =
    T

Les structures classiques sont les suivantes :

• if … then … else … end (« si…alors…sinon…fin de si »),
• if … then … elseif … then … else … end (« si…alors…ou si…alors … ou … fin de si »).

if … then doivent être écrits sur la même ligne, de même que elseif … then.

Exemple

Alice lance trois dés :

• si elle obtient trois 6, elle gagne 20 €,
• si elle obtient trois résultats identiques différents de 6, elle gagne 10 €,
• si elle obtient deux résultats identiques, elle gagne 5 €,
• sinon, elle ne gagne rien.

Simulez un lancer et calculez le gain d'Alice, en utilisant les fonctions :

• tirage_entier (simulations et statistiquesSimulations et statistiques),
• unique(D) qui ne garde qu'une fois les valeurs qui apparaissent plusieurs fois dans D,
• taille(unique(D)) qui donne la taille du vecteur ainsi obtenu, donc 1 si les trois termes sont égaux, 2 si deux termes sont égaux.

D=tirage_entier(3,1,6);
if D==[6,6,6] then
    G=20;
elseif taille(unique(D))==1 then
    G=10;
elseif taille(unique(D))==2 then
    G=5;
else
    G=0;
end
afficher("Alice gagne "+..
string(G)+ " euros")

• Pour tracer un point

Tracer le point a (1 ; 2) avec un point rouge.

Éditeur Scilab	Fenêtre graphique
Sélectionnez plot(1,2,".r")

• Pour tracer un segment

Tracer le segment [ab] en bleu (par défaut) avec a (1 ; 2) et b (3 ; 5).

Éditeur Scilab	Fenêtre graphique
Sélectionnez plot([1,3],[2,5])

• Pour tracer un cercle

Tracé du cercle de centre a (1 ; 2) et de rayon 5 en jaune dans un repère orthonormé.

Éditeur Scilab	Fenêtre graphique
Sélectionnez orthonorme;cercle(1,2,5,"y")

Pour une fonction kitxmlcodeinlinelatexdvpx\rightarrow f(x)finkitxmlcodeinlinelatexdvp définie sur un intervalle de , donnez avec la commande linspace les valeurs de x, en écrivant : x = linspace(a,b,n); où a est la plus petite valeur de la variable x, b est la plus grande valeur de x, et n le nombre de valeurs qui seront calculées entre a et b.

Ne pas oublier le « ; » sinon les n valeurs de x s'afficheront.

Par exemple, soient deux fonctions kitxmlcodeinlinelatexdvpffinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpgfinkitxmlcodeinlinelatexdvp définies sur [-2 ; 5] par :

Ci-dessous avec ce programme, on obtient le tracé de la courbe de kitxmlcodeinlinelatexdvpffinkitxmlcodeinlinelatexdvp, en bleu par défaut.

Éditeur Scilab	Fenêtre graphique
Sélectionnez function y=f(x) y=(x^2+2*x)*exp(-x) endfunction x=linspace(-2,5,50); plot(x,f)

En ajoutant le programme ci-dessous, on obtient le tracé des deux courbes, celle de f en rouge et celle de g en vert. Le tracé précédent a été effacé grâce à la commande clf (« clear figure » en anglais).

Éditeur Scilab	Fenêtre graphique
Sélectionnez function y=g(x) y=sin(x/2) endfunction x=linspace(-2,5,50); clf plot(x,f,"r",x,g,"g")

Termes d'une suite

Le cas le plus courant est celui où l'on veut tracer les points kitxmlcodeinlinelatexdvpM\left ( n, u\left ( n \right ) \right )finkitxmlcodeinlinelatexdvp après avoir calculé les coordonnées kitxmlcodeinlinelatexdvpu\left ( n \right )finkitxmlcodeinlinelatexdvp d'un vecteur kitxmlcodeinlinelatexdvp\vec{u}finkitxmlcodeinlinelatexdvp. On écrit alors plot(u,"*r") en spécifiant la forme et la couleur des points du nuage entre guillemets.

On a choisi ici des étoiles de couleur rouge qui ne sont pas reliées. Par défaut, les points sont bleus et reliés.

Éditeur Scilab	Fenêtre graphique
Sélectionnez for n=1:50 u(n)=(-0.8)^n; end clf; plot(u,"*r")

Statistiques doubles

les nuages statistiques sont donnés sous la forme de deux vecteurs : appelons les X et Y, on écrira alors plot(X,Y,"<") pour tracer le nuage des points kitxmlcodeinlinelatexdvpM\left ( X_{i};Y_{i} \right )finkitxmlcodeinlinelatexdvp avec des triangles bleus.

Éditeur Scilab	Fenêtre graphique
Sélectionnez X=[1,3,3,7,7,9,10]; Y=[8,7,5,5,4,2,2]; clf; plot(X,Y,"<")

Scilab permet de tracer des surfaces et des courbes dans l'espace avec un grand nombre d'options pour le traitement des faces cachées, la couleur des faces, les points de vue, etc. Nous ne donnerons ici que deux exemples.

La fonction kitxmlcodeinlinelatexdvpsurffinkitxmlcodeinlinelatexdvp permet de tracer une surface. Cette fonction prend trois variables d'entrée, x, y et z.

kitxmlcodeinlinelatexdvp\vec{x}finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp\vec{y}finkitxmlcodeinlinelatexdvp sont des vecteurs de taille respective kitxmlcodeinlinelatexdvpmfinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp correspondant à des points des axes kitxmlcodeinlinelatexdvp(O_{x})finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp(O_{x})finkitxmlcodeinlinelatexdvp. z est une matrice de dimension kitxmlcodeinlinelatexdvpn\times mfinkitxmlcodeinlinelatexdvp dont l'élément kitxmlcodeinlinelatexdvpz_{ij}finkitxmlcodeinlinelatexdvp est la cote du point de la surface d'abscisse kitxmlcodeinlinelatexdvpx_{i}finkitxmlcodeinlinelatexdvp et d'ordonnée kitxmlcodeinlinelatexdvpy_{j}finkitxmlcodeinlinelatexdvp.

Pour tracer la surface définie par une fonction du type kitxmlcodeinlinelatexdvpz=f\left ( x,y \right )finkitxmlcodeinlinelatexdvp, il faut donc :

• définir la fonction kitxmlcodeinlinelatexdvpffinkitxmlcodeinlinelatexdvp
• calculer z=feval(x,y,f)'
  feval(x,y,f) retourne la matrice kitxmlcodeinlinelatexdvpm\times nfinkitxmlcodeinlinelatexdvp dont l'élément kitxmlcodeinlinelatexdvpijfinkitxmlcodeinlinelatexdvp est kitxmlcodeinlinelatexdvpf=\left ( x_{i},y_{i} \right )finkitxmlcodeinlinelatexdvp que l'on va transposer en utilisant l'apostrophe « ' ».
• appliquer surf(x,y,z).

Le tracé de la surface kitxmlcodeinlinelatexdvpz=2x^{2}+2y^{2}finkitxmlcodeinlinelatexdvp (paraboloïde elliptique) :

Éditeur Scilab	Fenêtre graphique
Sélectionnez function z=f(x,y) z=2*x^2+y^2; endfunction x=linspace(-1,1,100); y=linspace(-2,2,200); z=(feval(x,y,f))'; clf; surf(x,y,z)

La fonction param3d permet de tracer une courbe dans l'espace. param3d prend trois arguments, x, y et z qui sont des vecteurs de même taille correspondant aux points kitxmlcodeinlinelatexdvp(x_{i}, y_{i}, z_{i})finkitxmlcodeinlinelatexdvp de la courbe.

Le tracé de l'hélice définie par kitxmlcodeinlinelatexdvp\left ( x=\cos\left ( t \right ),y=\sin\left ( t \right ), z=t \right )finkitxmlcodeinlinelatexdvp :

Éditeur Scilab	Fenêtre graphique
Sélectionnez t=linspace(0,4*%pi,100); param3d(cos(t),sin(t),t)

De nombreuses fonctions ont été créées dans le module lycée pour faciliter les simulations de façon rapide et performante.

Tirages aléatoires avec ordre et remise

• tirage_entier(p,m,n) retourne un vecteur de p tirages entiers aléatoires pris entre m et n avec p entier positif, m et n entiers et m ≤ n.

-->t=tirage_entier(4,1,6)
t =
    3.    1.    3.    6.

• tirage_reel(p,a,b) retourne un vecteur de p tirages réels aléatoires pris entre a et b avec p entier positif, a et b réels et a ≤ b.

-->tr=tirage_reel(2,-1,1)
tr =
    - 0.7460263762623 0.9377355421893

• frequence(n,s) retourne la fréquence de n dans la suite de nombres s avec n entier.

Par exemple, pour obtenir la fréquence d'apparition du 6 dans 1 000 lancers de dé :

-->t=tirage_entier(1000,1,6);
-->frequence(6,t)
ans =
    0.173

Tirages aléatoires sans ordre ni remise

Définir un ensemble

• la fonction ensemble permet de créer un ensemble :

->E=ensemble("e1","e2","e3")
E =
{e1,e2,e3}
-->E(1)
ans =
e1

Les éléments de l'ensemble e1, e2,… sont des chaînes de caractères. Un ensemble est non ordonné et n'a pas d'éléments dupliqués. Par exemple, {a,b,c} et {b,a,c,a} représentent le même ensemble. lorsqu'un ensemble est créé, les éléments dupliqués sont supprimés et, par commodité, ces éléments sont ordonnés par ordre alphabétique.

Il est possible d'attribuer des valeurs à des éléments d'un ensemble, par exemple pour des ensembles de pièces, de billets ou de cartes à jouer avec des valeurs. la valeur est donnée en la mettant entre parenthèses à la fin du nom de l'élément.

Par exemple, pour un ensemble U contenant trois boules rouges numérotées 1, 2, 3 et deux boules noires numérotées 1, 2, tapez :

-->U=ensemble("n(1)","n(2)","r(1)","r(2)","r(3)");

Il est également possible d'avoir des vecteurs de chaînes de caractères comme arguments de la fonction ensemble. Cela permet, par exemple, de créer facilement un ensemble dont les éléments sont des nombres entiers :

-->ensemble(string(1:9))
ans =
{1,2,3,4,5,6,7,8,9}

• la fonction valeur donne alors le vecteur des valeurs des éléments, permettant ainsi de les utiliser dans des calculs.

-->valeur(U)
ans =
    1.    2.    1.    2.    3.

• la fonction taille donne le nombre d'éléments d'un ensemble.

Pour comparer deux ensembles, on utilise l'opérateur habituel « == ».

• faire un tirage aléatoire dans un ensemble

On utilise la fonction tirage_ensemble en indiquant combien d'éléments on souhaite tirer.

Supposons que l'on tire deux boules dans l'ensemble U précédent et que l'on souhaite vérifier si elles sont rouges :

-->U=ensemble("n(1)","n(2)","r(1)","r(2)","r(3)");
-->R=ensemble("r(1)","r(2)","r(3)");
-->T=tirage_ensemble(2,U)
T =
{n(1),r(3)}
-->if inclus (T,R)==%T then
-->    afficher ("Les deux boules sont rouges")
-->else
-->    afficher("Les deux boules ne sont pas rouges")
Les deux boules ne sont pas rouges
-->end

Toutes les fonctions statistiques habituelles sont listées à la page 85.

Gardez particulièrement en mémoire :

• la fonction bar(x,n,couleur) qui trace des diagrammes en barres :

Éditeur Scilab	Fenêtre graphique
Sélectionnez x=[1:10]; n=[8,6,13,10,6,4,16,7,8,5]; clf; bar(x,n)

• pour un diagramme en barres représentant deux séries côte à côte : soit la série de valeurs X, et les deux séries d'effectifs n1 et n2. Pour le tracé, n1 et n2 doivent être des vecteurs colonne, c'est pourquoi dans l'exemple ci-dessous, on prend les transposées :

Éditeur Scilab	Fenêtre graphique
Sélectionnez X=[1,2,5];n1=[5,10,5];n2=[6,8,7]; bar(X,[n1',n2'])

• la fonction histogramme(a,n,couleur) qui permet de tracer l'histogramme d'une série statistique où les valeurs de la variable sont regroupées dans des intervalles. a est le vecteur donnant les bornes des intervalles dans l'ordre croissant et n est le vecteur des effectifs ou des fréquences correspondants. le vecteur a a un élément de plus que le vecteur n.

Éditeur Scilab	Fenêtre graphique
Sélectionnez a=[0,10,15,20,40]; n=[8,6,13,10]; clf; histogramme(a,n,"r")

Pour ces deux fonctions, l'argument optionnel couleur définit la couleur comme dans la fonction plot.

Les crochets permettent de définir une matrice. Un espace ou une virgule permet de passer d'une colonne à la suivante et un point virgule, d'une ligne à l'autre.

-->m=[1 2 3;4 5 6]
m =
    1.    2.    3.
    4.    5.    6.

Les parenthèses permettent d'accéder aux éléments ou de les modifier.

-->m(2,3)
ans =
    6.
-->m(2,3)=23
m =
    1.    2.    3.
    4.    5.    23.

L'opérateur « : » sert à désigner toutes les lignes ou toutes les colonnes d'une matrice.

Pour avoir la deuxième ligne de la matrice m, tapez :

-->m(2,:)
ans =
    4.    5.    23.

et la troisième colonne :

-->m(:,3)
ans =
    3.
    23.

Pour obtenir la transposée d'une matrice ou d'un vecteur, on utilise l'apostrophe « ' » :

-->m'
ans =
    1.    4.
    2.    5.
    3.    23.

Les opérations « * », « / » sont des opérations matricielles. Pour faire des opérations élément par élément, on fera précéder le signe opératoire d'un point : « .* », « ./ ».

-->A=[1,2,3;4,5,6]
A =
    1.    2.    3.
    4.    5.    6.

-->B=[1;1;2]
B =
    1.
    1.
    2.

-->A*B
ans =
    9.
    21.

-->A*A
    !--error 10
Multiplication incohérente.

-->A.*A
ans =
    1.    4.    9.
    16.    25.    36.

-->2*(A+2)
ans =
    6.    8.    10.
    12.    14.    16.

-->A/A
ans =
    1.            1.518259871D-16
    3.795187214D-15    1.

-->A./A
ans =
    1.    1.    1.
    1.    1.    1.

Dans le cas des vecteurs :

-->C=1:4
C =
    1.    2.    3.    4.

-->C*C
    !--error 10
Multiplication incohérente.

-->C.*C
ans =
    1.    4.    9.    16.

-->1/C
ans =
    0.0333333333333
    0.0666666666667
    0.1
    0.1333333333333

-->(1)./C
ans =
    1.    0.5    0.3333333333333    0.25

Pour résoudre le système linéaire AX = Y, où A est une matrice carrée, utilisez l'antislash « \ »

X = A \ Y ou bien la puissance -1 : X = A^(-1)*Y.

Attention, l'opération Y / A donnera (à condition que les dimensions soient bonnes) un autre résultat, soit la matrice Z telle que Z A = Y. l'opération X = A^(-1)*Y sera beaucoup plus coûteuse en temps de calcul.

Pour résoudre le système : kitxmlcodeinlinelatexdvp\begin{pmatrix} 1 & 2 & 3\\ 4 & 5 & 6 \end{pmatrix}\times X=\begin{pmatrix} 1\\1 \end{pmatrix}finkitxmlcodeinlinelatexdvp

-->A=[1 2 3;4 5 6];
-->Y=[1;1];
-->X=A\Y
X =
    - 0.5
    0.
    0.5
-->A*X
ans =
    1.
    1.

Trier

La fonction trier permet d'ordonner par ordre croissant ou décroissant les éléments d'un vecteur.

-->v=[2,6,9,6,-4,0,2]
v =
    2.    6.    9.    6.    - 4.    0.    2.
-->trier(v)
ans =
    - 4.    0.    2.    2.    6.    6.    9.
-->trier(v,">")
ans =
    - 4.    0.    2.    2.    6.    6.    9.
-->trier(v,"<")
ans =
    9.    6.    6.    2.    2.    0.     - 4.

Taille

La fonction taille retourne le nombre de coordonnées dans le cas d'un vecteur, et les dimensions (lignes, colonnes) dans le cas d'une matrice.

-->m=[1 2 3;4 5 6];
-->taille(m)
ans =
    2.    3.
-->U=[1:10]
U =
    1.    2.    3.    4.    5.    6.    7.    8.    9.    10.
-->taille(U)
ans =
    10.

Somme et produit

Les fonctions sum et prod calculent respectivement la somme et le produit des éléments de leur argument.

On reprend le vecteur U, vu au point précédent :

-->U=[1:10];
-->sum(U)
ans =
    55.
-->prod(U)
ans =
    3628800.

Unique

La fonction unique ne garde qu'une fois les éléments dans un vecteur (même si ceux-ci sont répétés plusieurs fois) et les ordonne par ordre croissant. Elle peut être très utile pour faire des tests (voir l'exemple 23Exemple 23).

-->v=[2,6,9,6,-4,0,2]
v =
    2.    6.    9.    6.    - 4.    0.    2.
-->unique(v)
ans =
    - 4.    0.    2.    6.    9.

Trouver

La fonction find permet de rechercher des éléments dans un vecteur ou une matrice et retourne un vecteur contenant les indices correspondants.

Pour trouver tous les éléments du vecteur w plus petits que 5 :

-->w=[1,5,3,8,14,7,3,2,12,6]; find(w<5)
ans =
    1.    3.    7.    8.

Le vecteur résultat (1,3,7,8) nous indique que les éléments w₁, w₃, w₇ et w₈ sont plus petits que 5.

Pour trouver tous les éléments du vecteur w égaux à 3 :

-->w=[1,5,3,8,14,7,3,2,12,6]; find(w==3)
ans =
    3.    7.

Le vecteur résultat (3,7) indique que les éléments w₃ et w₇ sont égaux à 3.

Les nombres ont une valeur absolue comprise entre environ 2,2 × 10^-308 et 1,8 × 10⁺³⁰⁸.

Le nombre %eps égal à 2.220446049D-16 donne la plus petite précision relative que l'on puisse espérer dans le calcul, soit environ 16 chiffres.

Exemple 1 : calcul de kitxmlcodeinlinelatexdvp\sin\left ( \pi \right )finkitxmlcodeinlinelatexdvp

-->sin(%pi)
ans =
    1.224646799D-16

La valeur de kitxmlcodeinlinelatexdvp\sin\left ( \pi \right )finkitxmlcodeinlinelatexdvp ci-dessus n'est pas 0, mais on la considère comme nulle. en effet, par rapport a la valeur maximale de la fonction sinus (soit 1), elle est égale a 0 avec une erreur inférieure a %eps.

Exemple 2 : testons si le triangle de cotes √3, 1 et 2 est rectangle :

-->a=sqrt(3)
a =
    1.7320508075689

-->b=1
b =
    1.

-->c=2
c =
    2.

-->a^2+b^2==c^2
ans =
F

-->abs(a^2+b^2-c^2)<%eps
ans =
F

-->abs(a^2+b^2-c^2)/c^2<%eps
ans =
T

Par défaut, les résultats sont affichés avec 16 caractères, comprenant le point décimal et le signe. la fonction format permet d'afficher plus de chiffres. Pour avoir 20 chiffres, vous taperez alors format(20).

Reprenons a = √3 :

-->a^2

-->format(20)
-->a^2
ans =
    2.99999999999999956

Calculez le prix TTC d'un article à partir de son prix HT, avec un taux de TVA à 19,6 %.

Algorithme

Lire le prix hors taxes et le mettre dans HT

Calculer le prix avec taxes et le mettre dans TTC

Afficher TTCA

Console Scilab

• dalcul et affichage simple :

-->HT=540;
-->TTC=HT*1.196
TTC =
    645.84

• demande de valeur et affichage mis en forme :

-->HT=input("Prix hors taxe : ");
Prix hors taxe : 3789
-->TTC=HT*1.196;
-->afficher("Le prix avec taxes ..
est "+string(TTC))
Le prix avec taxes est 4531.644

• fonction :

-->function TTC=f(HT);
-->    TTC=HT*1.196;
-->endfunction
-->f(540)
ans =
    645.84
-->f(3789)
ans =
    4531.644

Convertissez un temps donné en secondes, en heures, minutes et secondes.

Algorithme

Lire le temps en secondes, le mettre dans t

Mettre dans q le quotient de t par 60 (nombre de minutes)

Mettre dans s le reste (nombre de secondes)

Mettre dans h le quotient de q par 60 (nombre d'heures)

Mettre dans m le reste (minutes restantes)

Afficher heures, minutes, secondes

Console Scilab

• calcul et affichages simple :

-->t=12680;
-->q=quotient(t,60); s=reste(t,60);
-->h=quotient(q,60); m=reste(q,60);
-->[h,m,s]
ans =
    3.    31.    20.

• demande de valeur et affichage mis en forme :

-->t=input("Heure en secondes : ");
Heure en secondes : 4586
-->q=quotient(t,60);s=reste(t,60);
-->h=quotient(q,60);m=reste(q,60);
-->afficher(string(h)+" heures "+string(m)+" minutes "+..
string(s)+" secondes ")
1 heures 16 minutes 26 secondes

• fonction :

-->function y=f(t)
-->    q=quotient(t,60);s=reste(t,60);
-->    h=quotient(q,60);m=reste(q,60);
-->    y=[h,m,s]
-->endfunction
-->f(12680)
ans =
    3.    31.    20.
-->f(4586)
ans =
    1.    16.    26.

Calculez l'hypoténuse d'un triangle connaissant les deux côtés de l'angle droit.

Algorithme

Mettre le premier côté dans a

Mettre le deuxième côté dans b

Calculer kitxmlcodeinlinelatexdvp\sqrt{a^{2}+b^{2}}finkitxmlcodeinlinelatexdvp, le mettre dans c

Afficher c

Console Scilab

• calcul et affichage simple :

-->a=3; b=4;
-->c=sqrt(a^2+b^2)
c =
    5.

• demande de valeur et affichage mis en forme :

-->a = input("Premier côté : ");
Premier côté : 1
-->b = input("Deuxième côté : ");
Deuxième côté : sqrt(3)
-->c = sqrt(a^2+b^2);
-->afficher("Hypoténuse : "+string(c))
Hypoténuse : 2

• fonction :

-->function c=Hypotenuse(a,b)
-->    c=sqrt(a^2+b^2)
-->endfunction
-->Hypotenuse(4,5)
ans =
    6.4031242374328

Calculez les carrés des entiers naturels de 1 à 100.

Les 100 carrés constituent alors les coordonnées du vecteur c

for n=1:100
    c(n)= n^2;
end

-->c(74)
ans =
    5476.

Calculez 30 termes de la suite définie par : kitxmlcodeinlinelatexdvp\left\{\begin{aligned} &u_{0}=1\\ &u_{n+1}=u_{n}+2n+3 \end{aligned}\right.finkitxmlcodeinlinelatexdvp

Affichez les indices et les termes de la suite calculés, puis tracez le nuage de points.

u(1)=4;
for n=1:30
    u(n+1)=u(n)+2*n+3;
    afficher([n,u(n)])
end
clf; plot(u,"or")

Calculez le quotient q d'un nombre positif n par 11, par la méthode des soustractions successives (voir l'affectation d'une valeurDemander l'affectation d'une valeur).

N=input("N = ");
q=0;
while N>=11
    N=N-11;
    q=q+1;
end
afficher("quotient = "+string(q))

Bob place 5 000 € à intérêts composés à un taux de 2,7 % par an en 2009.

• calculez les sommes obtenues pendant les 20 prochaines années,
• tracez le nuage des sommes.

Algorithme

mettre 5 000 dans s(1) qui sera la somme de l'année 2008 + 1

(Par la suite S(n) sera la somme de l'année 2008 + n)

Pour n allant de 1 à 20

    Mettre kitxmlcodeinlinelatexdvps(n)finkitxmlcodeinlinelatexdvp multipliée par 1,027 dans kitxmlcodeinlinelatexdvps(n+1)finkitxmlcodeinlinelatexdvp.

    Afficher l'année et la somme

Fin de pour

Tracé du nuage

• effacez l'écran graphique,
• tracez le nuage des points (kitxmlcodeinlinelatexdvpn ; s(n)finkitxmlcodeinlinelatexdvp) avec des croix rouges.

Console Scilab	Fenêtre graphique
Sélectionnez -->S(1)=5000; -->for n=1:20 --> S(n+1)=S(n)*1.027; --> afficher([2008+n,S(n)]) -->end 2009. 5000. 2010. 5135. 2011. 5273.645 etc... -->clf -->plot(S,"+r")

Écrivez un programme lui permettant de savoir en quelle année il aura 7 000 €.

-->S=5000;
-->N=2009;
-->while S<7000
-->    S=S*1.027;
-->    N=N+1;
-->end
-->afficher("S dépasse 7000 € en : "+string(N))
S dépasse 7000 € en : 2022

Calculez 40 termes des suites an et bn définies par : kitxmlcodeinlinelatexdvp\left\{\begin{matrix} a_{i}=20\\ b_{i}=60 \end{matrix}\right.finkitxmlcodeinlinelatexdvp

et pour tout entier naturel n, kitxmlcodeinlinelatexdvp\left\{\begin{matrix} a_{n+1}=\frac{2a_{n}+b_{n}}{4}\\ b_{n+1}=\frac{a_{n}+2b_{n}}{4} \end{matrix}\right.finkitxmlcodeinlinelatexdvp

puis calculez les termes des suites kitxmlcodeinlinelatexdvp(u_{n})finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp(v_{n})finkitxmlcodeinlinelatexdvp définies par : kitxmlcodeinlinelatexdvpu_{n} = a_{n} + b_{n} \:finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpv_{n} = b_{n} - a_{n} \:finkitxmlcodeinlinelatexdvp.

a(1)=20 ; b(1)=60;
for n=1:40
    a(n+1)=(2*a(n)+b(n))/4;
    b(n+1)=(a(n)+2*b(n))/4;
    afficher([n,a(n),b(n)])
end
u=a+b; v=b-a;
afficher([u,v])

On pressent que u et v sont géométriques, vérifiez alors que le quotient de deux termes consécutifs est constant :

for n=1:40
    U(n)=u(n+1)/u(n);V(n)=v(n+1)/v(n)
end
afficher([U,V])

On remarque, à partir d'un certain rang, que les valeurs de v, au lieu d'être constantes, varient, puis affichent Nan (« not a number » en anglais). Cela est dû au fait que v tend vers 0 et devient trop petit pour la division :

0.75    0.25
0.75    0.3
0.75    0.1666666666667
0.75    1.
0.75    0.
0.75    Nan
0.75    Nan

En l'an 2000, le lycée a compte 2 000 élèves et le lycée b compte 8 000 élèves. Une étude montre que, chaque année :

• 10 % des élèves du lycée A quittent leur lycée pour aller au lycée B,
• 15 % des élèves du lycée B quittent leur lycée pour aller au lycée A.

Au bout de combien de temps le lycée a comptera-t-il plus d'élèves que le lycée b ?

a=2000;
b=8000;
n=2000;
while a<b
    c=0.9*a+0.15*b;
    b=0.1*a+0.85*b;
    a=c;
    n=n+1;
end
afficher("A dépasse B en "+string(n))

Les suites kitxmlcodeinlinelatexdvp(u_{n})\mathrm{\ et\ } (v_{n})finkitxmlcodeinlinelatexdvp sont définies par :

Calculez 200 termes de chaque suite et trouvez à partir de quel rang leur différence est inférieure à 0,01 puis calculez une valeur approchée de la limite commune aux deux suites à 0,01 près

for n=1:200
    u(n)=sum([1:n]^(-1))-ln(n);
    v(n)=sum([1:n]^(-1))-ln(n+1);
end
F=find(u-v < 0.01);
afficher("Le rang est : "+string (F(1)))
afficher("Limite : "+string (u(F(1))))

Cet exemple peut être traité plus simplement en affichant uniquement le rang à partir duquel la différence est inférieure à 0,01 et non pas les valeurs des termes des suites

n=1; d=ln(2);
while d > 0.01
    n=n+1;
    d=ln((n+1)/n);
end
afficher("Le rang est : "+string(n))

Calculez la distance entre deux nombres.

function y=d(a,b)
    if a>=b then
        y=a-b;
    else
        y=b-a;
    end
endfunction

Distance entre 3 et -5 :

-->d(3,-5)
ans =
    8.

Virginie lance trois dés numérotés de 1 à 6. si elle obtient une somme de 18, elle gagne 50 euros, entre 10 et 17, elle gagne 5 euros, sinon elle ne gagne rien.

T=tirage_entier(3,1,6);
S=sum(T)
if S<10 then
    afficher("Virginie ne gagne rien")
elseif S<18 then
    afficher("Virginie gagne 5 euros")
else
    afficher("Virginie gagne 50 euros")
end

Étant donné les trois côtés d'un triangle, élaborer un programme qui permet de déterminer si ce triangle est isocèle, équilatéral ou quelconque (voir l'affectation d'une valeurDemander l'affectation d'une valeur).

a=input("Premier côté = ");
b=input("Deuxième côté = ");
c=input("Troisième côté = ");
if a==b & b==c then
    afficher("Triangle équilatéral")
elseif a==b|a==c|b==c then
    afficher ("Triangle isocèle")
else
    afficher("Triangle quelconque")
end

Dichotomie

Rechercher une valeur approchée du nombre d'or, solution positive de l'équation kitxmlcodeinlinelatexdvp\: x^{2}=x+1finkitxmlcodeinlinelatexdvp

• définissez la fonction kitxmlcodeinlinelatexdvpf\: :\: f(x)=x^{2}-x-1finkitxmlcodeinlinelatexdvp
• tracez la courbe sur l'intervalle kitxmlcodeinlinelatexdvp[-5;5]finkitxmlcodeinlinelatexdvp

On remarque que la solution recherchée est entre 1 et 2.

• écrivez un programme permettant par dichotomie d'encadrer la solution recherchée dans un intervalle d'amplitude 10^-4, en partant des valeurs 1 et 2.

function y=f(x);
    y=x^2-x-1
endfunction
x=linspace(-5,5,100);
clf; plot(x,f)
a=1; b=2;
while b-a>10^(-4)
    c=(a+b)/2;
    if f(a)*f(c)>0 then
        a=c;
    else
        b=c;
    end
end
afficher("La solution est entre ..
"+string(a)+" et "+string(b))

La suite de syracuse est définie par : kitxmlcodeinlinelatexdvpu_{1}finkitxmlcodeinlinelatexdvp est donné, et pour :

Calculez les termes et vérifiez que, quel que soit u1, on finit toujours par arriver a 4, 2, 1. Pour cela, on définit la fonction syracuse qui donnera, en fonction du premier terme, le rang auquel on arrive a 1 et les termes de la suite.

function [u,n]=syracuse(u1)
    u(1)=u1; n=1;
    while u(n)<>1
        if pair(u(n))==%T then
            u(n+1)=u(n)/2;
        else
            u(n+1)=3*u(n)+1;
        end
        n=n+1;
    end
    afficher("Nombre de termes = "+string(n))
    afficher(u)
endfunction
syracuse(10000)

Tracez la courbe de la fonction cube entre - 2 et +2.

function y=f(x)
    y=x^3
endfunction
x=linspace(-2,2,100);
clf; plot(x,f)

Tracez en rouge la fonction kitxmlcodeinlinelatexdvpffinkitxmlcodeinlinelatexdvp définie par kitxmlcodeinlinelatexdvpf(x)=x+ \ln \left (\frac{x-1}{2x+3} \right )finkitxmlcodeinlinelatexdvp pour x entre 1 et 5.

Calculez les images de 2 et de kitxmlcodeinlinelatexdvp\sqrt{3}finkitxmlcodeinlinelatexdvp.

Console Scilab

-->function y=f(x); y=x+ln((x-1)/(2*x+3)); endfunction
-->x=linspace(1,5,100);
-->clf
-->plot(x,f,"r")
-->f(2)
ans =
    0.0540898509447
-->f(sqrt(3))
ans =
    - 0.4461185918724

Tracez les courbes des fonctions kitxmlcodeinlinelatexdvpf_{p}finkitxmlcodeinlinelatexdvp définies sur [0 ; 4] par : kitxmlcodeinlinelatexdvpf_{p}(x)=p\sqrt{x^{2}+9}+4-xfinkitxmlcodeinlinelatexdvp

Pour p = 2, puis pour p variant de 1 à 2 par pas de 0,1 et repérez un minimum éventuel.

Éditeur Scilab

function y=f(x); y=p*sqrt(x^2+9)+4-x; endfunction
x=linspace(0,4,100);
p=2;
clf; plot(x,f)
for p=1:0.1:2
    plot(x,f);
end
cliquer

Tracez la représentation graphique de la fonction kitxmlcodeinlinelatexdvpffinkitxmlcodeinlinelatexdvp définie par : kitxmlcodeinlinelatexdvp\left\{\begin{aligned} &f(x)=0\: si\: x\in [0;2[\\ &f(x)=x-2\: si\: x\in [2;4[\\ &f(x)=2x-6\: si\: x\in [4;7[ \end{aligned}\right.finkitxmlcodeinlinelatexdvp

Éditeur Scilab

function y=f(x); y=0; endfunction
function y=g(x); y=x-2; endfunction
function y=h(x); y=2*x-6; endfunction
clf
x=linspace(0,2,100); plot(x,f,"r")
x=linspace(2,4,100); plot(x,g)
x=linspace(4,7,100); plot(x,h,"k")

Le tracé n'est pas très lisible, en particulier celui du segment sur l'axe des abscisses. Cliquez sur Édition > Propriétés des axes, une nouvelle fenêtre s'ouvre (cette option n'est pas encore disponible sous Mac OS X).

Cliquez sur Compound (3) > Polyline (3) et choisissez d'augmenter l'épaisseur à 3 (Line). Vous remarquerez que les courbes sont numérotées dans l'ordre inverse de celui où elles ont été définies.

Avant :

Après :

Tracez la surface définie par : kitxmlcodeinlinelatexdvpz=4\times y^{2}+x+3yfinkitxmlcodeinlinelatexdvp, pour x entre -10 et 10 et y entre -5 et 5.

Éditeur Scilab	Fenêtre graphique
Sélectionnez function Z=g(x,y) z=4*x*y^2+x+3*y endfunction x=linspace(-10,10,100); y=linspace(-5,5,100); z=feval(x,y,g)'; clf; surf(x,y,z)

Calculez la fréquence d'apparition du 6 lors de la simulation de 10 000 lancers d'un dé à 6 faces numérotées de 1 à 6.

S=tirage_entier(10000,1,6);
f=frequence(6,S)

Simulez le lancer d'une pièce de monnaie sur 100 échantillons de taille 1 000. Tracez en bleu le nuage des 100 fréquences d'apparition du côté pile. Simulez avec des échantillons de taille 10 000. Tracez en rouge le nuage pour comparer les fluctuations.

Éditeur Scilab	Fenêtre graphique
Sélectionnez for n=1:100 T=tirage_entier(1000,0,1); p(n)=frequence(0,T) end clf; plot(p,"*") for n=1:100 T=tirage_entier(10000,0,1); p(n)=frequence(0,T) end plot(p,"r*")

Une puce se déplace sur un axe gradué. À chaque saut, elle se déplace d'une unité, de manière aléatoire et équiprobable vers la droite ou vers la gauche. Elle part de l'origine et effectue une marche de 30 sauts.

Proposez un algorithme donnant la position d'arrivée de la puce. Enrichissez l'algorithme précédent pour donner la liste des positions d'arrivée de n marches aléatoires. Tracez les fréquences des différentes positions.

x=0;
for i=1:30
    x=x+2*tirage_entier(1,0,1)-1;
end
afficher("Position de la puce : "..
+string(x))

• Algorithme

• Editeur Scilab

function P=f(N)
    for n=1:N
        P(n)=0;
        for i=1:30
            P(n)=P(n)+2*tirage_entier(1,0,1)-1;
        end
    end
endfunction

Calcul et tracé des fréquences pour N = 200

Éditeur Scilab	Fenêtre graphique
Sélectionnez a=f(200); for i=-30:30 fr(i+31)=frequence(i,a); end clf bar([-30:30],fr)

Élaborez un programme pour approcher la probabilité que dans une même classe de 30 élèves, 2 élèves au moins soient nés le même jour, en faisant 10 000 fois la simulation.

Définissez une fonction associant au nombre d'élèves de la classe la fréquence de cet événement, pour 1 000 simulations. À partir de combien d'élèves cette fréquence est-elle supérieure à 0,5 ?

y=0;
for n=1:10000
    dates=tirage_entier(30,1,365);
    if taille(unique(dates))<>30 then
        y=y+1/10000;
    end
end

function y=fr(e)
    y=0;
    for n=1:1000
        dates=tirage_entier(e,1,365);
        if taille(unique(dates))<>e then
            y=y+1/1000;
        end
    end
endfunction
e=linspace(20,28,9);
clf; plot(e,fr,"m<")
quadrillage

J'ai dans ma poche deux pièces de 10 centimes, une pièce de 20 centimes, trois pièces de 50 centimes, une pièce de 1 euro et deux pièces de 2 euros. Quelle est la probabilité pour qu'en sortant deux pièces au hasard de ma poche, je puisse payer une baguette à 1 euro ?

P=ensemble("a(0.1)","b(0.1)",..
  "c(0.2)","d(0.5)","e(0.5)",..
  "f(0.5)","g(1)","h(2)","i(2)");
f=0;
for k=1:1000
    t= tirage_ensemble(2,P);
    s=sum(valeur(t));
    if s >=1 then
        f=f+1/1000;
    end
end
afficher(f)

En 2000, dans le village de Xicun, en Chine, 20 enfants sont nés, parmi lesquels 16 garçons.

Dans la réserve d'Aamjiwnag, au Canada, entre 1999 et 2003, 132 enfants sont nés dont 46 garçons.

On supposera que la proportion habituelle de garçons à la naissance est de 50 % (elle est en réalité d'environ 51,2 %).

• Faire 100 simulations de chaque situation. Que peut-on en déduire ?

//Xicun
for k=1:100
    T=tirage_entier(20,0,1);
    GX(k)=taille(find(T==1));    ou bien    GX(k)=frequence(1,T)*20;
end
clf; quadrillage; plot(GX,".")
//AAmjiwnaag
for k=1:100
    T=tirage_entier(132,0,1);
    GA(k)=taille(find(T==1));    ou bien    GA(k)=frequence(1,T)*132;
end
clf; quadrillage; plot(GA,".")

Les résultats prouvent que moins de 5 % des réponses concordent avec la réalité. il y a donc autre chose que le hasard dans les deux cas.

Deux points a et b sont pris « au hasard » sur un segment de longueur 1. Quelle est la probabilité de l'événement : « la longueur ab est supérieure à 0,5 » ?

• Simuler une expérience aléatoire.
• Faire ensuite une boucle pour simuler 1000 fois l'expérience et construire le nuage des fréquences successives.

// On prend aléatoirement 2 nombres entre 0 et 1. On cherche la
// fréquence avec laquelle la distance entre eux est supérieure à 0,5.

On nomme kitxmlcodeinlinelatexdvpf (k)finkitxmlcodeinlinelatexdvp la fréquence avec laquelle la distance est supérieure à 1,5 lors de la kième simulation.

On initialise arbitrairement cette fréquence à 1.

N=1000; f(1)=1;
for k=1:N
    T=tirage_reel(2,0,1);
    d=abs(T(1)-T(2));
    D=floor(d+0.5);
    f(k+1)=(k*f(k)+D)/(k+1);
end
clf;quadrillage;plot(f,".")

d donne la distance entre les deux nombres. si 0 ≤ d < 0,5, alors D=0 et si 0,5 ≤ d ≤ 1, alors D=1.

Pour calculer kitxmlcodeinlinelatexdvpf (k+1)finkitxmlcodeinlinelatexdvp, on calcule de deux façons différentes le nombre de fois où la distance est supérieure à 0,5 lors de la (k+1)^ième simulation : kitxmlcodeinlinelatexdvp(k+1) f (k+1) = k f (k) + Dfinkitxmlcodeinlinelatexdvp.

On trouve que la fréquence se stabilise vers 0,25. On peut le prouver en admettant que la probabilité est égale à l'aire du domaine des points m (x,y) avec x et y dans [0 ; 1] et |x-y| > 0.5.

Jean-Claude Dusse s'inscrit pour 6 jours de cours de ski. On lui annonce qu'il ne peut pas choisir son moniteur, mais que celui-ci sera tiré au hasard chaque matin parmi l'équipe, qui comprend autant d'hommes que de femmes. Inquiet, Jean-Claude se demande quelles sont ses chances d'avoir une femme comme monitrice. il simule 100 000 semaines de cours de ski.

for k=1:100000
   t=tirage_entier(6,0,1);
   N(k)=taille(find(t==1));
end
for k=0:6
   fr(k+1)=frequence(k,N);
   afficher([k,fr(k+1)])
end
clf; bar(fr)

Après réflexion, Jean-Claude cherche seulement à approcher la probabilité d'avoir une monitrice au moins trois jours dans la semaine.

N=10000;
f=0;
for k=1:N
    t=tirage_entier(6,0,1);
    if taille(find(t==1))>=3 then
        f=f+1/N;
    end
end
afficher(f)

Un groupe de citoyens demande à la municipalité d'une ville la modification d'un carrefour en affirmant que 40 % des automobilistes tournent en utilisant une mauvaise file. Un officier de police constate que sur 500 voitures prises au hasard, 190 prennent une mauvaise file.

• Déterminer, en utilisant la loi binomiale sous l'hypothèse p = 0,4, l'intervalle de fluctuation au seuil de 95 %.

N=500;p=0.4;
RB=rep_binomiale(N,p);
m=find(RB>0.025); M=find(RB>=0.975);
afficher([(m(1)-1)/N,(M(1)-1)/N])

• D'après l'échantillon, peut-on considérer, au seuil de 95 %, comme exacte l'affirmation du groupe de citoyens ?

On trouve [0,358 ; 0,444].

Comme f = 0,38. l'affirmation est considérée comme exacte.

Programmer le calcul des coefficients du binôme de newton sous forme de tableaux (triangle de Pascal).

On va utiliser une matrice. Notons la P (comme Pascal). l'élément P(i,j) est la valeur figurant à la ligne i et la colonne j. La numérotation des lignes et des colonnes commence obligatoirement à 1, on aura donc un décalage :

On utilise le fait que pour tout entier naturel n, on a kitxmlcodeinlinelatexdvp\begin{pmatrix} n\\ 0\end{pmatrix} = \begin{pmatrix} n\\ n\end{pmatrix}=1finkitxmlcodeinlinelatexdvp

et que pour tous entiers naturels n et k tels que kitxmlcodeinlinelatexdvpk\leq n,\begin{pmatrix}n\\k\end{pmatrix}+ \begin{pmatrix}n\\k+1\end{pmatrix}= \begin{pmatrix}n+1\\k+1\end{pmatrix}finkitxmlcodeinlinelatexdvp

Une matrice étant toujours rectangulaire (ici carrée) les éléments qui n'auront pas été calculés seront automatiquement remplacés par des zéros. Faisons le calcul pour n lignes, ici par exemple n=10.

N=10;
P(1,1)=1;
for i=2:N
    P(i,1)=1;
    for j=2:i-1
        P(i,j)=P(i-1,j-1)+P(i-1,j);
    end
    P(i,i)=1;
end
afficher(P)

Des œufs en chocolat sont vendus par boîtes de 3. Certains œufs contiennent une figurine. Une collection est composée de 9 figurines. le problème à résoudre est de savoir combien il faudra acheter de boîtes d'œufs en moyenne pour avoir la collection complète, et combien cela va coûter.

Dans chaque boîte de 3 œufs, un seul contient une figurine. On suppose que les figurines sont uniformément réparties dans les boîtes, et on achète les boîtes une par une.

• Simuler avec Scilab en tirant au hasard parmi les entiers de 1 à 9. On créera une liste T qui au départ contient 9 zéros, et on remplacera le 0 par un 1 lorsque le numéro correspondant est tiré. On s'arrête lorsque tous les zéros sont remplacés par des 1, ce qui se teste facilement en calculant la somme des éléments de la liste T.
• Afficher le nombre n de boîtes qu'il a fallu acheter pour obtenir tous les entiers.
• Refaire 1000 fois cette simulation.

Simulation pour une collection

T=zeros(1,9);
n=0;
while sum(T)<>9
    n=n+1;
    A=tirage_entier(1,1,9);
    T(A)=1;
end
afficher(n)

1000 simulations

for k=1:1000
    T=zeros(1,9);
    n(k)=0;
    while sum(T)<>9
        n(k)=n(k)+1;
        A=tirage_entier(1,1,9);
        T(A)=1;
    end
end

• Faire une étude plus précise de la série statistique des valeurs de n obtenues : médiane et quartiles, moyenne et écart-type.
• Quel est le pourcentage de cas où il aura suffi d'acheter 25 boîtes ?
• Une boîte de 3 œufs en chocolat dont un seul contient une figurine vaut 2 euros. Combien doit-on dépenser en moyenne pour avoir la collection ?

//Calcul des indicateurs
me=mediane(n); afficher("Médiane : "+string(me))
Q=quartiles(n); afficher("Quartiles : "+string(Q(1))+" et "+string(Q(2)))
m=moyenne(n); afficher("Moyenne : "+string(m))
e=ecart_type(n); afficher("Ecart-type : "+string(e))
//Pourcentage de cas où 25 achats suffisent
t=taille(find(n<=25));
afficher("Dans "+string(t/1000)+" % des cas, 25 achats suffisent.")
//Moyenne des dépenses
afficher("On doit dépenser en moyenne "+string(2*m)+" euros pour..
avoir la collection entière.")

Écrire un programme qui permet de trouver la valeur de u pour que kitxmlcodeinlinelatexdvp\: P (-u<Z<u)= pfinkitxmlcodeinlinelatexdvp aveckitxmlcodeinlinelatexdvp\: Zfinkitxmlcodeinlinelatexdvp variable aléatoire suivant une loi normale centrée réduite et p prenant différentes valeurs entre 0 et 1, dont les valeurs classiques 0,95 et 0,99.

p=0.95;
u=1;
while 2*loi_normale(u,0,1)-1<p
    u=u+0.01;
end
afficher("Pour p = "+string(p)+" on a u = "+string(u))

X est une variable aléatoire suivant la loi normale de paramètres m et s.

Écrire un programme qui calcule les probabilités que X appartienne à un intervalle de la forme kitxmlcodeinlinelatexdvp[m-ks\: ;\: m+ks]finkitxmlcodeinlinelatexdvp pour k = 1, 2 et 3 (voir l'affectation d'une valeurDemander l'affectation d'une valeur).

m=input("Moyenne de X : ");
s=input("Ecart-type de X : ");
for k=1:3
    p=1-2*loi_normale(m-k*s,m,s);
    afficher([k,p])
end

Comment déterminer les différents intervalles de fluctuation ?

Déterminer les intervalles de fluctuation avec la loi binomiale au seuil de 0.95 :

• si l'on veut symétriser les probabilités que X soit à l'extérieur de l'intervalle,
• si l'on veut le plus petit intervalle centré autour de l'espérance,
• si l'on veut l'intervalle d'amplitude minimale.

Nous choisissons d'établir les intervalles de fluctuation autour de la fréquence. dans ce corrigé, n=100 et p=0,3, ces valeurs peuvent être changées. On rajoute les intervalles de fluctuation calculés avec les formules du cours de seconde et de terminale.

n=100; p=0.3;
// Symétrisation des probabilités que X soit à l'extérieur de l'intervalle
RB=rep_binomiale(n,p);
m=find(RB>0.025); M=find(RB>=0.975);
afficher("Intervalle symétrique")
afficher([(m(1)-1)/n,(M(1)-1)/n])
//Intervalle centré sur l'espérance
e=n*p;
k=0;
while rep_binomiale(n,p,e+k)-rep_binomiale(n,p,e-k)<0.95
    k=k+1;
end
afficher("Intervalle centré sur l''espérance")
afficher([(e-k)/n,(e+k)/n])
// Le plus petit intervalle
for j=1:n
    for i=1:j
        d(i,j)=rep_binomiale(n,p,j)-rep_binomiale(n,p,i-1);
    end
end
[i,j]=find(d>=0.95);
[diff,k]=min(j-i)
afficher("Plus petit intervalle")
afficher([i(42)/n,j(42)/n])
//L'intervalle vu en seconde
afficher("Intervalle vu en seconde")
afficher([p-1/sqrt(n),p+1/sqrt(n)])
//L'intervalle de fluctuation asymptotique au seuil de 0.95
u=1.96;
afficher("Intervalle de fluctuation asymptotique")
afficher([p-u*sqrt(p*(1-p)/n),p+u*sqrt(p*(1-p)/n)])

Déterminez le quotient et le reste dans la division de a par b, a et b positifs.

function d=diveucl(a,b)
    q=0;
    while a>=b
        a=a-b;
        q=q+1;
    end
    d=[q a]
endfunction
diveucl(1224,15)

On définit la fonction diveucl qui, aux deux variables a et b (a>b>0), associe deux valeurs : le quotient et le reste.

Déterminez si un nombre entier a est premier, avec a > 2.

On définit la fonction prem qui, au nombre entier a, associe la phrase « a est premier » si a est premier et « a est composé » sinon. On regarde à part la divisibilité par 2 qui permet ensuite de ne tester que les diviseurs impairs.

function prem(a)
    if reste(a,2) == 0 then
        afficher("a est composé")
        return
    end
    n=floor(sqrt(a));
    for d=3:2:n
        if reste(a,d)==0 then
            afficher ("a est composé")
            return
        end
    end
    afficher("a est premier")
endfunction
prem(2^32+1)

Décomposez un entier positif a en facteurs premiers.

On définit la fonction decomp qui, au nombre entier positif a, associe la liste de ses diviseurs premiers.

function y=decomp(a)
    y=[]
    while reste(a,2)==0
        y=[y,2]
        a=a/2;
    end
    n=floor(sqrt(a))
    for d=3:2:n
        while reste(a,d)==0
            y=[y,d];
            a=a/d;
        end
    end
    if a<>1 then
        y=[y,a]
    end
endfunction
decomp(4560)

Déterminez le plus grand commun diviseur de deux entiers strictement positifs a et b. On définit la fonction PGCD qui, au couple (a,b), associe son plus grand commun diviseur.

for n=1:50
    N(n)=3*n^2-n+1;
    D(n)=2*n-1;
    r(n)=reste(N(n),D(n));
    afficher([n,r(n)])
end
clf
plot(r,"+")

Coder le message « j aime les mathematiques » en utilisant le codage progressif : la première lettre est décalée de 1, la deuxième de 2… la k^ième de k.

m="j aime les mathematiques"
afficher("Message à coder")
afficher(m)
m=strsubst(m," ","");
m=ascii(m);
n=taille(m);
for k=1:n
    M(k)=m(k)+k
    if M(k)>122 then
        M(k)=M(k)-26;
    end
end
M=ascii(M);
afficher("Message codé")
afficher(M)

Le texte suivant : « CGQXXQnQXXQVaGdZQQ » a été codé avec la méthode de César. en testant successivement toutes les clés possibles, décodez-le.

m="CGQXXQNQXXQVAGDZQQ"
m=ascii(m);
n=taille(m);
for k=1:25
    Mk=m-k;
    for i=1:n
        if Mk(i)<65 then
            Mk(i)=Mk(i)+26;
        end
    end
    Mk=ascii(Mk);
    afficher("Message décodé avec.. la clé "+string(k))
    afficher(Mk)
end

Pour décoder un message secret, il peut être utile de compter la fréquence d'apparition des lettres dans un texte. Pour cela, on a mis le texte écrit en majuscules, sans accent, dans un fichier texte enregistré sous le nom de « Texte.txt ». le programme va compter et afficher la fréquence de chaque lettre présente dans le texte.

m=mgetl("chemin menant au fichier\Texte.txt ")
m=strsubst(m," ","");
m=ascii(m);
format(5)
for i=1:26
    f(i)=frequence(i+64,m);
    if f(i)<>0 then
        afficher("La fréquence de ..
            "+string(ascii(i+64))+" est "+string(f(i)))
    end
end
clf; quadrillage; bar(f)
axes=gca( );
axes.x_ticks.labels=strsplit(ascii(65:90))

Simulez le jeu du lièvre et de la tortue.

On lance un dé équilibré. si on obtient le 6, le lièvre a gagné, et une nouvelle partie commence. Sinon, la tortue avance et on relance le dé. La tortue doit avancer 5 fois pour gagner (5 tirages consécutifs sans le 6).

On cherche à simuler un grand nombre de parties pour approcher la probabilité de gagner de chacun.

L=0
T=0
for P=1:5000
    n=0;
    while %T
        d=tirage_entier(1,1,6);
        if d==6 then
            L=L+1;
            break;
        else
            n=n+1;
        end
        if n==5 then
            T=T+1;
            break;
        end
    end
end
afficher([L/(L+T),T/(L+T)])

Résolvez l'équation différentielle kitxmlcodeinlinelatexdvp\left\{\begin{aligned} &y'(x)=y(x)\\ &y(0) =1 \end{aligned}\right.finkitxmlcodeinlinelatexdvp par la méthode d'Euler et Comparez le résultat obtenu à la solution exacte kitxmlcodeinlinelatexdvpy (x) = e^{x}finkitxmlcodeinlinelatexdvp. La suite obtenue par la méthode d'Euler est donnée par : kitxmlcodeinlinelatexdvp\left\{\begin{aligned} &y_{1}=1\\ &y_{i} =y_{i-1}+\mathrm{d}x\ y_{i-1} \end{aligned}\right.finkitxmlcodeinlinelatexdvp où dx est le pas en x.

function y=f(x)
    y=exp(x)
endfunction
function y=euler(b,dx)
    n=floor(b/dx);
    x=0:dx:(n-1)*dx;
    y(1)=1;
    for i=2:n
        y(i)=y(i-1)+dx*y(i-1);
    end
    clf; plot(x,y,x,f,"r")
endfunction
euler(5,0.1)

Approximation d'une aire.

Étant donné une fonction kitxmlcodeinlinelatexdvpffinkitxmlcodeinlinelatexdvp positive et monotone sur [a ; b], on veut encadrer l'intégrale de f entre a et b par les sommes des aires des rectangles.

Application à la fonction racine carrée entre 0 et 10 :

function [s,S]=sommes(a,b,n)
    S=0; s=0;
    for k=0:n-1
        s=s+f(a+k*(b-a)/n);
        S=S+f(a+(k+1)*(b-a)/n);
    end
    s=s*(b-a)/n; S=S*(b-a)/n;
endfunction
function y=f(x)
    y=sqrt(x)
endfunction
[s,S]=sommes(0,1,10)

Dans une ville, des trains roulant dans les deux sens relient la gare (G), la plage (P), le musée (M) et le belvédère (B) selon le graphe suivant :

• Donnez la matrice a associée au graphe GPMB.
• Calculez A⁶ et déduisez combien de chaînes de longueur 6 commencent et se terminent à la gare.

-->A=[0 1 0 1;1 0 1 0;0 1 0 1;1 0 1 0]
A =
    0.    1.    0.    1.
    1.    0.    1.    0.
    0.    1.    0.    1.
    1.    0.    1.    0.
-->B=A^6
B =
    32.    0.    32.    0.
    0.     32.   0.     32.
    32.    0.    32.    0.
    0.     32.   0.     32.
-->afficher ("Il y a "+string(B(1,1))+" chaînes de ..
longueur 6 commençant et se terminant à la gare.")
Il y a 32 chaînes de longueur 6 commençant et se terminant à la gare.

n personnes numérotées de 1 à n jouent.

Le meneur de jeu donne un ticket à la première, puis saute 1, donne un ticket à la troisième, puis saute 2, donne un ticket à la sixième, etc, et recommence en tournant et en sautant une personne de plus à chaque fois. si la personne a déjà un ticket, on ne lui en redonne pas.

• Pour quelles valeurs de n tous les joueurs auront-ils un ticket ?
• Si le meneur de jeu fait payer chacun 1 euro et donne 2 euros à toutes les personnes ayant un ticket, pour quelles valeurs de n est-il gagnant ?

Les réponses à ces questions ne sont pas évidentes du tout. On peut prouver qu'au bout de 2n distributions de tickets, on boucle sur les mêmes personnes. On définira une fonction qui au nombre n de joueurs fait correspondre le vecteur u à n coordonnées égales à 1 si le joueur correspondant a un ticket, à 0 sinon.

• Editeur Scilab

function u=f(n)
    i=1;
    k=1;
    u=zeros(1,n);
    u(1)=1;
    for k=1:2*n
        j=reste(i+k,n)+1;
        u(j)=1;
        if sum(u)==n then
            break
        end
        i=j;
    end
endfunction

• Cherchons dans quel cas tous les joueurs auront un ticket :

for a=1:500
    if sum(f(a))==a then
        afficher(a)
    end
end

• Le meneur de jeu prend 1 euro par personne et donne 2 euros à ceux qui ont un ticket. Définissions la fonction gain de ce qu'il gagne :

function y=gain(x);
    y=x-2*sum(f(x));
endfunction
x=linspace(1,50,50);
clf
quadrillage
plot(x,gain,"*")