Scilab pour les vrais débutants

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

--> %e
 %e  =
    2.7182818

--> %pi
 %pi  =
    3.1415927

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

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

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.618034

Les noms des principales fonctions sont récapitulés au chapitre IIIProgrammer de ce document. Par exemple :

--> exp(10)/factorial(10)
 ans  =
    0.0060699

Il est possible d'utiliser la touche tabulation →│ de son clavier pour compléter len 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 factorial et factor. Il suffit alors de double-cliquer sur la fonction souhaitée ou de la sélectionner avec la souris, ou les touches ↑ ↓ et d'appuyer sur la touche Entrée (Windows et Linux), ou Retour (Mac OS X) pour l'insérer.

• 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.

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.

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.

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.

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 kitxmlcodeinlinelatexdvp(u_n)finkitxmlcodeinlinelatexdvp définie par : kitxmlcodeinlinelatexdvp\begin{cases} u_1=1 \\ u_{n+1}=2u_n-3 \end{cases}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 et des nuages de points.

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 mollette 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.

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).

Pour accéder à l'aide en ligne, cliquez sur ? > Aide Scilab dans la barre de menus, ou tapez dans la console :

-->help

Pour obtenir de l'aide sur des fonctions, tapez dans la console help et le nom de la fonction souhaitée. Par exemple :

-->help sin

affichera l'aide de la fonction sin (sinus).

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, 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.7853982
--> a
 a  =
    0.7853982

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.5707963

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 des fonctions numériques à une variable. 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.4999745
--> g(12.5)
 ans  =
    9.5555556

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

III-A-4-a. Écrire▲

III-A-4-b. Les crochets▲

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

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

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

III-A-4-c. La fonction disp▲

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

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

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

-->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 : kitxmlcodeinlinelatexdvp\begin{cases} u_1 = 4 \\ u_{n+1} = u_n+2n+3 \end{cases}finkitxmlcodeinlinelatexdvp

u(1)=4;
for n=1:20
  u(n+1)= u(n)+2*n+3;
  disp([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
disp("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 deux 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.

On peut simuler un lancer et calculer le gain d'Alice, en utilisant les fonctions :

• grand ;
• unique(D) qui ne garde qu'une fois les valeurs qui apparaissent plusieurs fois dans D; ;
• length(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=grand(1,3,"uin",1,6);
if D==[6,6,6] then
  G=20;
elseif length(unique(D))==1 then
  G=10;
elseif length (unique(D))==2 then
  G=5;
else
  G=0;
end
disp("Alice gagne"+..
string(G)+ "euros")

III-D-1-a. 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")

III-D-1-b. 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 une fonction kitxmlcodeinlinelatexdvpx→f(x)finkitxmlcodeinlinelatexdvp on donne d'abord les valeurs de x avec la commande linspace 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 est 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 f et g définies sur [-2 ; 5] par :

Ci-dessous avec ce programme, on obtient le tracé de la courbe de f, 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")

III-D-3-a. Termes d'une suite▲

Le cas le plus courant est celui où l'on veut tracer les points kitxmlcodeinlinelatexdvpM(n,u(n))finkitxmlcodeinlinelatexdvp après avoir calculé les coordonnées kitxmlcodeinlinelatexdvpu(n)finkitxmlcodeinlinelatexdvp d'un vecteur kitxmlcodeinlinelatexdvp\vec{u}\vphantom{y}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")

III-D-3-b. 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 de points kitxmlcodeinlinelatexdvpM(X_i;Y_i)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 surf permet de tracer une surface. Cette fonction prend trois variables d'entrée, x, y et z. x et y sont des vecteurs de taille respective m et n correspondant à des points des axes (Ox) et (Oy). z est une matrice de dimension n×m dont

l'élément kitxmlcodeinlinelatexdvpz_{ij}finkitxmlcodeinlinelatexdvp est la cote du point de la surface d'abscisse kitxmlcodeinlinelatexdvpx_ifinkitxmlcodeinlinelatexdvp et d'ordonnée kitxmlcodeinlinelatexdvpy_jfinkitxmlcodeinlinelatexdvp.

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

• définir la fonction kitxmlcodeinlinelatexdvpffinkitxmlcodeinlinelatexdvp ;
• Calculer z=feval(x,y,f)' ; feval(x,y,f) retourne la matrice m×n dont l'élément ij est kitxmlcodeinlinelatexdvpf(x_i,y_j)finkitxmlcodeinlinelatexdvp que l'on va transposer en utilisant l'apostrophe « ' » ;
• Appliquer surf(x,y,z).

Le tracé de la surface kitxmlcodeinlinelatexdvpz=2x^2+y^2finkitxmlcodeinlinelatexdvp (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(x=\cos(t),y=\sin(t),z=t)finkitxmlcodeinlinelatexdvp :

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

De nombreuses fonctions existent pour effectuer des simulations de façon rapide et performante.

III-D-5-a. Tirages aléatoires avec ordre et remise▲

-->t= grand(1,4,"uin",1,6)
 t  = 
    3.    1.    3.    6.

-->tr= grand(1,2,"unf",-1,1)
 tr  = 
  - 0.7460264    0.9377355

Gardez particulièrement en mémoire :

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

É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'])

L'argument optionnel couleur définit la couleur comme dans la fonction plot.

Les crochets permettent de définir une matrice. Une espace ou une virgule permettent 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.518D-16  
    3.795D-15    1.

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

III-E-2-a. 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.0333333  
    0.0666667  
    0.1        
    0.1333333

-->(1)./C
 ans  = 
    1.    0.5    0.3333333    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.

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.

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.

III-E-4-a. Trier▲

-->v=[2,6,9,6,-4,0,2]
 v  = 
    2.    6.    9.    6.  - 4.    0.    2.  
 
--> gsort(v,"g","i")
 ans  = 
  - 4.    0.    2.    2.    6.    6.    9.  

--> gsort(v)
 ans  = 
    9.    6.    6.    2.    2.    0.  - 4.

III-E-4-b. Taille▲

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

-->m=[1 2 3;4 5 6];
 
-->size(U)
 ans  = 
    2.    3.

III-E-4-c. Somme et produit▲

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

-->prod(U)
 ans  = 
    3628800.

III-E-4-d. Unique▲

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

III-E-4-e. Trouver▲

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

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

Les nombres ont une valeur absolue comprise entre environ kitxmlcodeinlinelatexdvp2,2\times10^{-308}finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp1,8\times10^{+308}finkitxmlcodeinlinelatexdvp.

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

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

La valeur de sin(π) ci-dessus n'est pas 0, mais on la considère comme nulle. En effet, par rapport à la valeur maximale de la fonction sinus (soit 1), elle est égale à 0 avec une erreur inférieure à %eps.

Par défaut, les résultats sont affichés avec 10 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 kitxmlcodeinlinelatexdvpa=\sqrt3finkitxmlcodeinlinelatexdvp  :

-->a^2
 ans  = 
    3.

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