Le tableur

# Chapitre 1 Le tableur

## 1.1 Généralités

### 1.1.1 Pour ouvrir un niveau contenant un tableur

Pour avoir un tableur, il faut utiliser le menu `Edit`, puis `Ajouter`, puis `Tableur,statistiques` ou le raccourci `Alt+t`.
On vous demande un nom, pour la sauvegarde ultérieure de ce tableur. C’est ce nom de variable qui servira à sauver la matrice définie par le tableur et c’est ce nom suivi du suffixe `.tab` qui sera de nom du fichier contenant le tableur et ses formules. Par exemple, si vous donnez comme nom `M`, la variable `M` contiendra la matrice définie par le tableur et lorsque vous appuyez sur le bouton `Save M.tab`, le fichier `M.tab` sera le fichier qui contiendra le tableur avec toutes ses formules et que l’on pourra retrouver lors de séances ultérieures.
Attention Si vous ne donnez pas de nom, le bouton `Save` ne sera pas visible et il le deviendra si vous utilisez `Table->Sauver tableur comme du texte` et vous donnez, par exemple,comme nom `M`.
Si le contenu du tableur change, la matrice `M` change sans avoir besoin de sauver, par contre le fichier `M.tab` ne changera que si l’on sauve c’est à dire si on appuie sur `Save M.tab`. On peut aussi sauver la sélection par exemple `A0:C3` vers une variable (menu `Table`), cette variable contiendra une matrice qui ne changera pas même si le tableur change.
La `Configuration generale` du menu `Configuration` permet de déterminer le nombre de lignes et de colonnes que l’on aura lors de l’ouverture du tableur.

### 1.1.2 Déscription d’un niveau contenant un tableur

Dans un niveau contenant un tableur nous avons :

- en haut la barre de menu de ce niveau :
  `Table Edit Maths`.
  On peut retrouver ces menus avec un click droit de la souris n’importe où dans le tableur et on retrouve aussi ces menus dans le menu `Tableur` du menu général.
  À coté de cette barre de menus les boutons :
  `eval val init 2-d 3-d` ou par exemple
  `eval val init 2-d 3-d Save M.tab`,
- une ligne composée de deux cases :
  - la case de sélection qui permet soit de sélectionner une cellule (en tapant par exemple `B0`) ou un sous tableau (en tapant par exemple `B0..D3` ou `B0:D3`), ou un sous tableau avec des colonnes non contigües (en tapant par exemple `B0..3,D`), soit de savoir ce qui est sélectionné avec la souris.
  - une ligne de commande qui permet de modifier une cellule du tableur ou de savoir ce qui se trouve dans cette cellule.
    `Attention`
    Il faut savoir que si le curseur est dans cette ligne de commande, lorsqu’on clique dans une case, c’est le nom de cette case qui va s’afficher dans cette ligne, sans changer la case de sélection. Pour enlever le curseur de la ligne de commande tapez sur `Echap` ou `Escap` ou encore sur la touche d’effacement ⇐ qui effacera ce qui se trouve dans cette ligne y compris le curseur. Si le curseur n’est pas dans la ligne de commande, lorsqu’on clique dans une case, c’est la valeur de cette case qui va s’afficher dans cette ligne, en mettant son nom dans la case de sélection.
- la ligne d’état rappelant la configuration choisie : c’est aussi un bouton qui permet de configurer le tableur.
  On détermine la configuration soit en appuyant sur la ligne d’état soit on utilise le menu :
  `Edit``▸``Configuration` du tableur.
  On a par exemple dans la ligne d’état :
  `* Spreadsheet M R40C6 auto down fill`
  cela veut dire que l’on a un tableur qui a été modifié depuis la dernière sauvegarde (`*`), de nom de variable `A` qui a 40 lignes et 6 colonnes, il est réévalué automatiquement, le curseur se déplace vers le bas lorsqu’on vient de remplir une cellule et une matrice remplit plusieurs cellules.
  On peut aussi avoir par exemple :
  `- Matrix <> R4C6 manual right cell`
  cela veut dire que l’on a une matrice qui n’a pas été modifiée depuis la dernière sauvegarde (`-`), il ne lui correspond pas de nom de variable (`<>`), elle a 4 lignes et 6 colonnes, elle n’est réévaluée que si on appuie sur le bouton `eval`, le curseur se déplace vers la droite lorsqu’on vient de remplir une cellule et une matrice remplit une seule cellule.
- le tableur ou l’éditeur de matrice. Si on a coché `Graphe` dans la configuration du tableur, on aura aussi un écran de représentation graphique du tableur : cet écran se trouve soit en dessous du tableur si on a coché `Paysage`, soit à sa droite si on a décoché `Paysage`. C’est dans cet écran que s’afficheront toutes les commandes graphiques situées dans les cellules du tableur. Par exemple, on met `1` dans `A0`, `2` dans `B0`, `=cercle(A0,B0)` dans `C0` et `=cercle(B0,A0)` dans `D0`. On obtient le tracé de deux cercles et une modification de l’une des cases `A0` ou `B0` modifira ce tracé.

### 1.1.3 Tableur et éditeur de matrice

Le tableur est une feuille de calculs ayant la forme d’un tableau composé de lignes et de colonnes qui déterminent des cases appelées cellules. Les cellules contiennent des valeurs ou des commandes ou encore des formules qui font références aux autres cellules.
Un éditeur de matrice a aussi la forme d’un tableau composé de lignes et de colonnes qui déterminent des cases, mais ces cases ne peuvent contenir que des scalaires.
Dans le menu `Edit``▸``Configuration` du tableur, l’item `Format` permet d’avoir soit un tableur, soit un éditeur de matrice permettant d’entrer facilement des matrices quelconques ou symétriques ou etc...On a donc la possibilité lorsque l’on veut mettre dans le tableur une matrice particulière (par exemple une matrice symétrique) de choisir de le faire dans l’éditeur de matrice associé au tableur (on choisit par exemple `matrice symétrique` dans `Format`), on entre la matrice (les éléments symétriques sont mis automatiquement) puis, on repasse en mode tableur en choisissant `Tableur` dans `Format`.

#### Description de l’écran du tableur

Le tableur est un tableau composé de colonnes désignées par les lettres majuscules `A,B,C,...` et de lignes numérotées par `0,1,2,...`.
Les cases du tableur sont appelées cellules.
Ainsi, `A0` désigne la première cellule du tableur.

#### Description de l’éditeur de matrice

L’éditeur de matrice est un tableau composé de lignes et de colonnes numérotées par `0,1,2,...`
Les cases de l’éditeur de matrice sont les éléments de la matrice.
Si on sauve la matrice en lui donnant comme nom `M`, `M[0,1]` désigne la case située dans la ligne de numéro `0` et dans la colonne de numéro `1`.

### 1.1.4 Principe et configuration du tableur

Le menu `Edit``▸``Configuration` du tableur permet de configurer le tableur (tableur se traduit en anglais par `Spreadsheet`).
Le tableur est une feuille de calculs ayant la forme d’un tableau composé de lignes et de colonnes. Lorsqu’on a choisit `Recalculer automatiquement` dans le menu `Edit``▸``Configuration` du tableur, les cases ou cellules sont mises à jour automatiquement lorsque l’on modifie une des cases et sinon il faut utiliser le bouton `eval` ou utiliser dans le menu `Edit``▸``Configuration` du tableur, la commande `Evaluer le tableur` (à exécution directe) ou encore utiliser le raccourci clavier en appuyant sur `F9`.
L’item `Format` de ce menu configuration permet d’avoir soit un tableur, soit un éditeur de matrice permettant d’entrer facilement des matrices quelconques ou symétriques ou etc..
On peut préciser le nombre de lignes et de colonnes avec lesquelles on veut travailler : par exemple pour entrer une matrice symétrique il faut avoir le même nombre de lignes et de colonnes, on change ce nombre avec les items `Changer le nombre de lignes` et `Changer le nombre de colonnes` dans le menu `Edit``▸``Configuration` du tableur.
On pourra bien sûr modifier ces nombres au cours du travail, par exemple en utilisant le menu :
`Edit``▸``Configuration``▸``Ajouter/effacer` du tableur ou en utilisant la `case de sélection` (si on met `G50` dans cette case, il y aura alors création d’un nombre suffisant de lignes et de colonnes pour pouvoir sélectionner `G50`) Toutes les fonctions (même graphiques) de `Xcas` sont utilisables dans le tableur.
Le bouton `STOP` permet d’interrompre un calcul trop long.

### 1.1.5 La `case de sélection`

La `case de sélection` est la case située en dessous du menu `Table`.
La `case de sélection` est une case interactive :
- elle permet de connaitre le nom de la (ou des) cellule(s) sélectionnée(s) avec la souris (si on sélectionne `A3`, `A3` se note automatiquement dans cette case, si on sélectionne `A2,A3,A4,B2,B3,B4`, `A2:B4` se note automatiquement dans cette case),
- elle permet aussi d’aller directement sur une cellule dont on spécifie le nom : en effet lorsqu’on appuie sur cette case le curseur apparait, et on peut remplacer, par exemple, `A3` par `A30` : les lignes (et les colonnes) nécessaires sont créées et la cellule `A30` se trouve sélectionnée.
- elle permet aussi de sélectionner une ou plusieurs colonnes, par exemple, en tapant dans cette case `A0:C9` ou `A0..C9` cela sélectionnera les 10 premières lignes des colonnes `A,B` et `C` ou encore en tapant dans cette case `A0..9,C` cela sélectionnera les 10 premières lignes des colonnes `A` et `C`. Grâce à cette case de sélection on peut donc sélectionner des colonnes non contigües, ce que l’on ne peut pas faire avec la souris.

### 1.1.6 Les différents boutons d’un tableur

Les différents boutons du tableur sont :

- `eval` pour évaluer le tableur lorsqu’on n’est pas en mode automatique. On peut aussi utiliser le menu, `Edit``▸``Configuration``▸``Recalculer automatiquement`. Cela permet de passer en mode automatique de façon à ce que le tableur soit évalué après chacune de ses modifications,
- `val` pour avoir la valeur de la cellule dans la ligne de commande à la place de la formule,
- `init` pour avoir, par exemple, une variable qui compte le nombre d’évaluation du tableur : on met par exemple :
  - `j:=0` dans la case `Init sheet` de la configuration du tableur et
  - `=(j:=j+1)` dans une cellule du tableur.
    À chaque évaluation la cellule contiendra `1,2...`. En appuyant sur `init` on réinitialise la valeur de `j` et on remet la cellule à `1`
- `Save` si vous n’avez pas donné de nom à l’ouverture, ce bouton n’existe pas. pour le créer, utiliser `Table->Sauver tableur comme du texte`. Si vous avez donné un nom à l’ouverture par exemple `toto`, le bouton `Save` sauve alors à la fois le tableur et ses formules dans le fichier `toto.tab` (d’extension `.tab`) et les valeurs dans la matrice `toto`. La matrice `toto` pourra alors être reutilisée et le fichier `toto.tab` pourra être inséré dans un tableur lors de séances ultérieures.
- `2-d 3-d` ouvre un écran de gépmétrie 2-d ou 3-d pour que l’on puisse voir les commandes graphiques du tableur

## 1.2 La barre de menu d’un tableur

### 1.2.1 Le menu `Table` d’un tableur

Le menu `Fich` est composé de :

- Si vous avez donné un nom à l’ouverture, `Sauver` est identique au bouton `Save` et sauve le tableur dans un fichier d’extension `.tab`. L’extension `.tab` est rajoutée automatiquement. Si vous n’avez pas donné de nom à l’ouverture, `Sauver` vous en demande un, par exemple `toto` et `Sauver` crée le bouton `Save` et il sauve à la fois le tableur et ses formules dans le fichier `toto.tab` (d’extension `.tab`) et les valeurs dans la matrice `toto`. La matrice `toto` pourra alors être reutilisée et le fichier `toto.tab` pourra être inserer dans un tableur lors de séances ultérieures.
- `Sauver comme` sauve le tableur sous un nom (d’extension `.tab`) différent de celui noté à coté du bouton `Save`,
- `Sauver selection vers variable` pour stocker dans une variable la matrice mise en surbrillance et pouvoir ainsi utiliser cette variable ailleurs (calcul formel par exemple). Par exemple si le nom de la variable est `a`, `a[0,2]` donnera dans une ligne de commandes la valeur située à la ligne 0 et à la colonne 2 de la sous-matrice selectionnée,
- `Inserer` pour mettre à partir de la cellule mise en surbrillance un tableur sauvé précédemment,
- `Nom de variable` pour donner un nom de variable au tableur différent du nom de fichier sans son suffixe `.tab`. Ce nom est noté dans la ligne d’état située en dessous de la ligne de commande. Par exemple si le nom de la variable est `M`, `M[0,1]` renvera la valeur située en `B0`,
- `Imprimer` pour imprimer le tableur. Vous pouvez prévisualiser avant d’imprimer.

### 1.2.2 Le menu `Edit` d’un tableur

On trouve dans ce menu :

- `Evaluer le tableur F9` pour recalculer le tableur lorsqu’on n’est pas en mode automatique : pour que le recalcul soit automatique, il faut passer en mode automatique avec le menu `Edit``▸``Configuration``▸``Recalculer automatiquement`. Le raccourci clavier de cet item `Evaluer le tableur` est `F9` et il a le même effet que le bouton `eval` : cela permet de recalculer les cellules du tableur après une modification.
- `Copier la cellule` (en anglais `Cell copy`) permet de recopier une cellule dans une autre cellule : on sélectionne à la souris la cellule que l’on veut recopier. On clique ensuite sur `Copier la cellule` puis, on clique sur la cellule à remplir et on clique sur le bouton `coller` du bandeau général ou on utillise l’item `Coller` ci-après.
- `Coller` sert à copier ce qui a été auparavant sélectionné.
- `Configuration` contient les items suivants :
  - `Format` permet de choisir d’avoir un tableur ou un éditeur de matrice permettant d’éditer facilement des matrices symétriques, antisymétriques, hermitiennes, antihermitiennes,quelconques,
  - `Changer le nombre de lignes` permet de spécifier le nombre de lignes du tableur ou de la matrice,
  - `Changer le nombre de colonnes` permet de spécifier le nombre de colonnes du tableur ou de la matrice,
  - `Déplacer ->` la surbrillance ira automatiquement sur la cellule située à droite de la cellule que l’on vient de remplir,
  - `Déplacer vers le bas` : la surbrillance ira automatiquement sur la cellule située en dessous, de la cellule que l’on vient de remplir,
  - `Recalculer automatiquement` pour que le tableur soit recalculé automatiquement après chaque modification,
  - `Ne pas recalculer automatiquement` pour que le tableur ne soit pas recalculé automatiquement : le recalcul ne se fait alors que si on appuie sur le bouton `eval`,
  - `Distribuer une matrice sur plusieurs cellules` pour remplir plusieurs cellules avec une matrice : par exemple si on sélectionne `A0` et que l’on tape dans la ligne de commandes du tableur `[1,2,3]`, cela remplira 3 cellules, en mettant 1 dans `A0`, 2 dans `B0` et 3 dans `C0`, par contre si on tape dans la ligne de commandes du tableur `=[1,2,3]` cela mettra [1,2,3] dans `A0`.
  - `Conserver une matrice dans une seule cellule` permet de remplir une cellule avec une matrice : par exemple si on sélectionne `A0` et que l’on tape dans la ligne de commandes du tableur `[1,2,3]` ou `=[1,2,3]`, cela mettra [1,2,3] dans `A0`.
- `Trier` permet de trier plusieurs lignes (resp colonnes) selon l’ordre croissant (resp décroissant) d’une colonne (resp ligne).
  Par exemple on a dans les colonnes `A` et `B` :
  `[[3,9],[5,12],[2,14],[4,8],[1,11]]` qui represente le numéro d’une copie et sa note.
  On peut alors :
  - soit trier ce tableau pour ordonner le numéro des copies par ordre croissant (c’est à dire par rapport à la colonne `A`) on demande alors : `Col/crois` puis on marque `A`. On obtient alors le tableau :
  `[[1,11],[2,14],[3,9],[4,8],[5,12]]`
  - soit trier ce tableau pour ordonner les notes des copies par ordre décroissant (c’est à dire par rapport à la colonne `B`) on demande alors : `Col/décrois` puis on marque `B`. On obtient alors le tableau :
  `[[2,14],[5,12],[1,11],[3,9],[4,8]]`
  Attention
  Pour trier une colonne dans une autre colonne du tableur, on ne peut pas le faire directement, car quand on écrit une formule dans le tableur, elle ne peut remplir que la case courante (sinon cela poserait trop de problèmes pour les dépendances des cellules).
  Le remplissage par une matrice n’est possible qu’en évaluation directe sans dépendances.
  Si on veut trier la colonne `A` dans `B`, on crée une cellule par exemple `C0` avec `=sort(A0:A10)`, `C0` contient alors la liste `A0:A10` triée.
  Puis dans `B0` on écrit `=($C$0)[Row()]` et on recopie `B0` vers le bas : on obtient alors la recopie de la liste `C0` dans `B` puisque `Row()` désigne l’indice de la cellule dans laquelle la formule est recopiée, indice qui est aussi l’indice des éléments de la liste `C0`.
- `Remplir` contient les items suivants :
  - `Remplir sélection de 0` remplit la sélection par des zéros,
  - `Copier vers la droite` recopie sur toutes les cellules situées à droite de la cellule mise en surbrillance, le contenu (ou la formule) qui s’y trouve,
  - `Copier vers le bas` recopie sur toutes les cellules situées en dessos de la cellule mise en surbrillance, le contenu (ou la formule) qui s’y trouve,
  - `Remplir la sélection avec la cellule enfoncée`, recopie le contenu (ou la formule) de la cellule qui a débuté la sélection faite avec la souris de la zone rectangulaire dans laquelle on veut faire une recopie (la cellule que l’on copie est donc un des quatre coins de la zone rectangulaire),
  - `Remplir sélection de 0` remplit la sélection avec des zéros,
  - `Remplir le tableur de 0` remplit le tableur avec des zéros,
  - `tablefunc` permet d’avoir une table numérique des valeurs d’une expression (voir 1.6.1),
  - `tableseq` permet d’avoir les valeurs numériques des termes d’une suite récurrente (voir 1.6.2),
- `Ajouter/effacer` contient les items suivants :
  - `Inserer ligne` rajoute une ligne juste avant la ligne où se trouve la cellule mise en surbrillance,
  - `Ligne+ en fin` rajoute une ligne à la fin du tableur,
  - `Inserer colonne` rajoute une colonne juste avant la colonne où se trouve la cellule mise en surbrillance,
  - `Col+ en fin` rajoute une colonne à la fin de tableur,
  - `Effacer ligne courante` supprime la ligne où se trouve la cellule mise en surbrillance,
  - `Effacer selection lignes` efface le contenu des lignes sélectionnées,
  - `Effacer col courante` supprime la colonne où se trouve la cellule mise en surbrillance,
  - `Effacer sélection cols` efface le contenu des colonnes sélectionnées,
- `Col+grande` agrandit ou diminue la taille des colonnes,
- `Col+petite` diminue la taille des colonnes,

### 1.2.3 Le menu `Maths` d’un tableur

#### Le menu `Maths``▸``stats 1-d` d’un tableur

Le menu `Statistics` ouvre pour chaque item une boite de dialogue où l’on peut préciser : la sélection, la cellule cible (c’est dans cette cellule que s’inscrira la commande choisie), si comme argument de la commande choisie, on doit considérer les lignes ou les colonnes de la sélection et si on doit mettre les valeurs ou les références de la sélection .
Voici les différents items du menu `Maths``▸``stats 1-d` :

- `camembert`
  On peut faire plusieurs camemberts sur le même graphique en sélectionnant toute une plage.
  Exemple pour faire deux camemberts
  On sélectionne la plage `A0:C3`.
  On met
  - dans `A0` n’importe quoi sauf une chaine vide par exemple 2
  - dans `A1,A2,A3` : `"A","B","C"`
  - dans `B0` le titre du premier camembert par exemple `"xyz"`,
  - dans `B1,B2,B3` : les valeurs du premier camembert par exemple `2,5,7`
  - dans `C0` le titre du second camembert par exemple `"xyz"`,
  - dans `C1,C2,C3` : les valeurs du second camembert par exemple `5,6,7`
  Puis on met dans `D0` : `=camembert(matrix(4,3,(A0):(C3)))` à l’aide du menu `Math``▸``Proba_stats``▸``1-d``▸``camembert`.
  On obtient :
- `batons`
  On peut faire plusieurs diagrammes en batons sur le même graphique en sélectionnant toute une plage.
  Exemple pour faire deux diagrammes en batons
  Avec l’exemple ci-dessus, on met dans `D0` : `=diagramme_batons(matrix(4,3,(A0):(C3)))` à l’aide du menu `Math``▸``Proba_stats``▸``1-d``▸``batons`.
  On obtient :
- `plotlist`
  Si `plotlist` a comme argument une liste `L=[y1,...,yn]`, cela trace la ligne reliant les points d’abscisse `1,...,n` et d’ordonnée `L=[y1,...,yn]` et si `plotlist` a comme argument une matrice `M=[[x1,y1],...,[xn,yn]]`, cela trace la ligne reliant les points de coordonnées `xn,yn`.
  Exemple On met dans `A` : `1,2,5,7,9` et dans `B` : `3,5,6,9,4` On tape dans `C0` : `=plotlist((A0):(B4),’affichage’=1)`
  On tape dans `C1` ou on utilise le menu `Math``▸``Proba_stats``▸``1-d``▸``plotlist` avec pour plage `A0:B4` et pour cellule cible `C1` : `=plotlist(matrix(5,2,(A0):(B4)))`
  Attention ! Lorsqu’on met `=plotlist((A0):(B4))` la plage `(A0):(B4)` est applatie en une liste (ici la liste `1,3,2,5,4,6,7,9,9,4`) On obtient en rouge la ligne correspondant à la liste et en noir celle correspondant à la matrice :
- `Boite à moustaches` (en anglais `Boxwhiskers`)
  `Boite à moustaches` permet de dessiner, dans l’écran graphique associé au tableur, les boites à moustaches des colonnes (ou des lignes si `Lignes` est cochée) des données qui ont été sélectionnées. C’est dans la cellule cible que s’inscrit la commande `moustache` avec comme argument les valeurs ou les références de la plage sélectionnée selon que l’on coche ou non `valeur`.
- `Classes (donnees ou donnees/eff)`
  `Classes` permet de définir des classes : on sélectionne une colonne du tableur contenant la série que l’on veut regrouper en classes (ou si on a des effectifs, on sélectionne deux colonnes du tableur representant les données et leurs effectifs) puis, on sélectionne `Classes` dans le menu `Statistiques` sous-menu `1-d` : il faut vérifier la valeur minimum de la classe, la largeur des classes (ces deux cases sont déjà remplies avec les valeurs spécifiées dans la configuration du graphique (bouton rouge `geo`) et aussi la cellule cible qui est la première cellule à partir de laquelle on écrira les classes sur deux colonnes, Les intervalles des classes s’inscrivent dans la colonne de la cellule cible et commencent par `classe_min` et la longueur des intervalles est égale à `classe_size` : ces valeurs peuvent être spécifiées dans la configuration du graphique (bouton rouge `geo`). La colonne suivante contient les effectifs des classes obtenues dans la précédente colonne,
- `Histogramme (intervalles/eff)` (en anglais `Histogram`)
  `Histogramme` permet de dessiner dans l’écran graphique associé au tableur l’histogramme de deux colonnes sélectionnées representant les intervalles de données et leurs effectifs, et inscrit la commande `histogram` correspondante dans la cellule cible.

#### Le menu `Maths``▸``stats 2-d` d’un tableur

Le menu `Maths``▸``stats 2-d` contient les items suivants :

- `Scatterplot` permet de tracer sur l’écran graphique les points d’abscisse la première colonne sélectionnée et d’ordonnée les autres colonnes sélectionnées si `lignes` n’est pas coché ou de tracer sur l’écran graphique les points d’abscisse la première ligne sélectionnée et d’ordonnée les autres lignes sélectionnées si `lignes` est coché. Les couleurs seront différentes pour les points dont les ordonnées sont dans des colonnes (resp lignes) différentes.
  Par exemple,
  - si `lines` n’est pas coché, on remplit :
    `A0,A1,A2,A3` avec `1,2,3,4` et
    `B0,B1,B2,B3` avec `1,4,9,16`, puis
    on sélectionne la matrice `A0:B3` et on ouvre le menu `Statistiques 2-d Scatterplot`.
  - si `lines` est coché, on remplit :
    `A0,B0,C0,D0` avec `1,2,3,4` et
    `A1,B1,C1,D1` avec `1,4,9,16`, puis
    on sélectionne la matrice `A0:D1` et on ouvre le menu `Statistiques 2-d Scatterplot`.
  Une boite de dialogue s’ouvre où la plage sélectionnée est marquée (si vous n’avez rien sélectionné il faut remplir cette case) puis, il faut donner le nom de la `cellule cible` là où la commande `scatterplot` va s’inscrire. Les valeurs ou les références de la plage sélectionnée seront en argument de la commande `scatterplot` selon que l’on coche ou non `valeur`.
  Supposons que `lignes` n’est pas coché.
  - Si `valeur` n’est pas coché dans la boite de dialogue et si la cellule cible est `C0`, dans la ligne de commande du tableur et dans `C0` il s’inscrit alors :
    `=scatterplot(matrix(4,2,(A0):(B3)))`
  - Si `valeur` est coché dans la boite de dialogue et si la cellule cible est `C1`, dans la ligne de commande du tableur et dans `C1` il s’inscrit alors :
    `=scatterplot([[1,1],[2,4],[3,9],[4,16]])`.
  Ainsi une modification des valeurs de `A0:B3` modifira, lors d’une réévaluation du tableur,le graphique commandé par la case `C0` mais ne modifira pas le graphique commandé par la case `C1`. Autrement dit, si vous ne travaillez pas en valeur, c’est à dire avec des références, à chaque modification, on aura une modification du graphique et si vous travailler en valeur à chaque modification il faudra inscrire dans une nouvelle cellule cible la commande `scatterplot` et on aura alors plusieurs graphiques correspondant chacun aux commandes `scatterplot` des cellules cibles.
  `Attention`
  Lorsqu’on sélectionne une plage avec la souris on ne peut sélectionner que des colonnes contigües. On peut néanmoins remplir la plage de sélection de la boite de dialogue avec des colonnes non contigües par exemple :
  `C0..5,A,D` pour dire, si `lines` n’est pas coché, que les points que l’on veut représenter ont pour abscisses la colonnes `C` et pour ordonnées la colonne `A` d’une part et pour abscisses la colonnes `C` et pour ordonnées la colonne `D` d’autre part. Mais dans ce cas `scatterplot` s’affichera comme si `valeur` etait coché (même si ce n’est pas le cas).
- `Polygonplot` permet de tracer sur l’écran graphique les points d’abscisse la première colonne sélectionnée et d’ordonnée les autres colonnes sélectionnées, en reliant entre eux les points dont les ordonnées sont dans une même colonne.
  La même boite de dialogue que pour `scatterplot` s’ouvre. Dans la ligne de commande du tableur il s’inscrit alors, par exemple, dans `D5` :
  `=polygonplot(matrix(3,3,A0:C2))` si ni `lignes` ni `valeur` ne sont cochés, si la cellule cible est `D5` et si la plage selectionnée est `A0:C2`.

## 1.3 Pour remplir le tableur

### 1.3.1 Comment remplir une cellule

Dans une cellule on peut mettre :

- une chaine de caractère, ou une expression numérique ou formelle : pour cela il suffit de sélectionner la cellule à remplir et de taper dans la ligne de commande ce que l’on veut mettre dans la cellule, puis de valider avec `enter`,
- une formule faisant référence aux autres cellules, dans ce cas il faut faire précéder la formule du signe `=` (voir la section 1.3.3 références absolues et relatives).
  Attention
  1/ Si le curseur ne se trouve pas dans la ligne de commande, lorsqu’on clique sur une cellule, la ligne de commande s’efface et le contenu de la cellule (valeur ou formule) s’affiche dans la ligne de commande.
  2/ Si le curseur se trouve dans la ligne de commande, il faut que la ligne de commande soit vide, pour que, lorsqu’on clique sur une cellule son contenu s’affiche dans la ligne de commande.
  3/ Si le curseur se trouve dans la ligne de commande, et que celle-ci contient quelque chose (par exemple `=`), alors lorsqu’on clique sur une cellule c’est son nom qui s’affiche dans la ligne de commande (ce qui facilite l’édition d’une formule).
  4/ On enlève le curseur de la ligne de commande avec `Esc` ou `Echap`.
  Ainsi, si la ligne de commande est vide et si, par exemple, on clique sur `A1` (qui contient `3`) alors le contenu de `A1` (`3`) s’affiche dans la ligne de commande :
  - on peut cliquer dans une autre cellule et alors ligne de commande s’efface et son contenu s’affiche dans la ligne de commande.
  - on peut cliquer dans la ligne de commande, taper quelque chose (par exemple `+`), puis cliquer sur une autre cellule (par exemple `A2`) et alors le nom de la cellule `A2` apparaità la suite du contenu précédent (`3+`).
  Donc quand on édite le contenu d’une case, si on clique dans le tableur alors, le nom ou la plage des noms selectionnés, s’affichent dans la ligne de commande.
  Exemple
  On veut remplir la case `A1` avec la formule `1+A2` :
  - on efface la ligne de commande,
  - on clique sur `A1`,
  - on clique sur la ligne de commande et on tape `=1+`,
  - on clique sur la cellule `A0` puis, `Enter`.
  Cela marque `1+A0` dans la cellule `A1`.
  Pour annuler une modification en mode édition, il n’est donc pas possible de simplement cliquer sur une autre cellule du tableur puisque cela recopierait le nom de cette autre cellule. En ligne de commande, c’est la touche `Esc` qui annule l’édition.
- une liste ou une matrice à condition de faire précéder la liste ou la matrice du signe `=` car, si on ne met pas le signe `=` cela aura pour effet de remplir plusieurs cellules (voir ci-dessous).
  On peut remplir d’un seul coup plusieurs cellules à partie d’une cellule lorsque l’on met dans cette cellule une liste ou une matrice.
  Par exemple :
  Dans `A0` on met : `[1,2,3]`, cela a pour effet de remplir `A0` avec `1`, `B0` avec `2` et `C0` avec `3`.
  Dans `A0` on met : `[[1,2],[3,4]]`, cela a pour effet de remplir `A0` avec `1`, `B0` avec `2`, `A1` avec `3` et `B1` avec `4`.
  Attention
  Le remplissage de plusieurs cellules à l’aide d’une matrice ou d’une liste n’est possible qu’en évaluation directe sans dépendance. Par exemple :
  On ne peut pas mettre `[A0,B0]` dans `C0`, mais on peut mettre `=[A0,B0]` dans `C0`. Le signe `=` est necessaire pour remplir une seule cellule avec une liste ou une matrice.
  Exemple
  Pour mettre une liste ou une matrice dans une case il faut mettre le signe `=` devant la liste ou la matrice.
  On tape dans la case `A0` :
  `=[[1,2],[3,4]]`
  On obtient dans la case `A0` :
  `[[1,2],[3,4]]`
  Si l’on ne met pas le signe égal on peut remplir d’un seul coup plusieurs cases du tableur par les éléments de la liste ou de la matrice à condition que la formule mise ne fasse pas référence aux autres cellules.
  On tape dans la case `A0`:
  `[[1,2],[3,4]]`
  On obtient :
  `A0=1`, `B0=2`, `A1=3`, `B1=4`
  Autre exemple
  Dans `A0` je tape :
  `ranm(2,3,4)`
  Je remplis alors d’un seul coup les 6 cases : `A0,B0,C0,A1,B1,C1` avec les éléments de la matrice `[[1,3,1],[2,1,2]]` (en effet `ranm(2,3,4)` renvoie une matrice de 2 lignes et 3 colonnes d’entiers pris au hasard de façon équirépartie dans l’ensemble des 4 nombres `0,1,2,3`.
  Cette matrice est définie une fois pour toute car la formule `ranm(2,3,4)` est évaluée puis oubliée.
  Dans `A0` je tape :
  `=ranm(2,3,4)`
  Cette fois, seule la cellule `A0` est remplie avec la matrice :
  `[[1,2,3],[3,2,2]]`.
  Cette matrice changera à chaque modification du tableur sauf, si on a choisi `Ne pas recalculer automatiquement` dans la configuration du tableur (avec le menu `Edit``▸``Configuration`).

### 1.3.2 Pour voir le contenu d’une cellule

Lorsqu’on consulte le tableur, toutes les cellules sont évaluées. Pour voir le contenu évalué d’une cellule située hors du champ de vision, on utilise, soit le curseur vertical (situé à droite du tableur) qui permet de voir les dernières lignes, soit le curseur horizontal (situé à la dernière ligne du tableur) qui permet de voir les dernières colonnes.
Remarque
Lorsque toutes les cellules sont visibles, ces deux curseurs ne sont pas présents.
Pour voir le contenu non évalué d’une cellule (c’est à dire ce que l’on a mis, initialement, dans la cellule comme formule ou comme valeur), il suffit de cliquer sur cette cellule : il apparait alors dans la ligne de commande la formule (ou la valeur) qui a été mise dans cette cellule.
Pour faire apparaitre dans la ligne de commande, le contenu évalué de la cellule, il suffit d’appuyer sur le bouton `eval`.
Lorsque le résultat est trop grand (ou trop petit) en taille on peut avoir besoin d’agrandir une colonne pour voir ce résultat entièrement (ou de diminuer la colonne pour gagner de la place). Par exemple, on veut modifier la taille de la colonne `B`, on déplace la souris sur le trait vertical qui sépare `B` de `C` : le curseur devient ↔. On clique avec la souris et, sans relacher le bouton de la souris, on déplace ce trait vertical pour agrandir ou diminuer la largeur de la colonne `B`. Lorsque le résultat est trop grand, on peut aussi appuyer sur le bouton `eval` pour faire apparaitre ce résultat dans la ligne de commande.

### 1.3.3 Références absolues et relatives

Dans une cellule on peut mettre :
- une chaine de caractères,
- une expression algébrique,
- une formule faisant référence à d’autres cellules. Ces références peuvent être absolues ou relatives à la cellule qui contient la formule. Les références absolues sont obtenues en rajoutant `$` devant la lettre désignant la colonne ou devant le numéro de la ligne de la cellule référence.
Les références relatives permettent de désigner les cellules par rapport à une autre : ainsi `A0` mis dans la cellule `B1` désigne la cellule située dans la colonne précédente et à la ligne précédente et c’est cette information qui sera recopiée quand on recopiera la formule vers le bas ou vers la droite.
Exemples :
Dans `A0` il y a 1 et je tape dans `B1` la formule :

- `$A$0+2` : dans `B1` il y aura 3, et si je recopie cette formule vers le bas, j’obtiens des 3 dans la colonne `B` car je recopie dans toutes les cases de la colonne `B` la formule `$A$0+2`. Si je recopie cette formule vers la droite, j’obtiens aussi des 3 dans la première ligne, car je recopie dans toutes les cases de la première ligne la formule `$A$0+2` puisque `$A$0` est la référence absolue de la case `A0`.
- `$A0+2` : dans `B1` il y aura 3, et si je recopie cette formule vers le bas cette formule deviendra `$A1+2` dans `B2`, `$A2+2` dans `B3`. La valeur de `B2` dépend donc de la valeur de `A1`, la valeur de `B3` dépend donc de la valeur de `A2` etc...
  Si je recopie cette formule vers la droite, cette formule deviendra `$A0+2` dans `C1`, `$A0+2` dans `D1` ...j’obtiens donc une ligne de 3. `$A0` fait toujours référence à la colonne `A` : `A` est une référence absolue mais `0` désigne ici la ligne précédente puisque `$A0` a été mis dans `B1`.
- `A$0+2` : dans `B1` il y aura 3, et si je recopie cette formule vers le bas, j’obtiens des 3 dans la colonne `B` mais si je recopie cette formule vers la droite, cette formule deviendra `B$0+2` dans `C1`, `C$0+2` dans `D1` etc...
- `A0+2` : dans `B1` il y aura 3, et si je recopie cette formule vers le bas, cette formule deviendra `A1+2` dans `B2`, `A2+2` dans `B3` etc...si je recopie cette formule vers la droite, cette formule deviendra `B0+1` dans `C1`, `C0+1` dans `D1` etc...

### 1.3.4 Référence d’un sous-tableau

Il y a deux façons de désigner un morceau du tableur selon que l’on veut remplir une cellule ou le sélectionner dans la `case de sélection`.
Il sera désigné par :

- dans une cellule, par la référence de sa première case puis "deux points" (`:`), puis la référence de sa dernière case.
  Les références de la première ou de la dernière case seront selon les cas, absolues ou relatives, mais attention cela est valable pour des colonnes contigües et représente une liste i.e. le tableau est aplati,
- dans la `case de sélection` par référence de sa première case puis "point point" (`..`), puis le numéro de la dernière ligne, puis virgule (`,`) suivi de la séquence des lettres désignant les colonnes. Cette fois cela représente une matrice est on peut facilement désigner des colonnes non contigües.

Remarque Dans la `case de sélection`, on ne peut pas utiliser "deux points" (`:`) comme séparateur entre les deux références.
Exemple
Dans une cellule `A0:B5` représente la liste des valeurs de `[A0,B0,A1,B1,..,A5,B5]` constituée par la matrice "aplatie".
Dans la `case de sélection`, `A0..B5` désigne le tableau de 6 lignes (lignes 0,1..5) et 2 colonnes (colonnes `A` et `B`).
On a aussi la possibilité de désigner dans la `case de sélection` des colonnes non consécutives, on écrira par exemple `A0..10,C,E` pour sélectionner les 11 premières lignes des colonnes `A`, `C` et `E`.
Attention!!!
Seule la `case de sélection` permet de définir un sous-tableau ou une matrice.
Donc dans une cellule pour désigner un sous-tableau on peut reconstituer la matrice à l’aide de la commande `list2mat` (qui transforme une liste en matrice selon le nombre de colonnes spécifié) si les colonnes sont consécutives ou en utilisant la commande `tran` (qui transforme une matrice en sa transposée).
Dans la cellule `F0` on tape par exemple :
`=list2mat(A0:B5,2)` pour avoir une matrice avec 2 colonnes et 6 lignes Dans la cellule `F0` on tape par exemple :
`=list2mat(A0:D5,4)` pour avoir une matrice avec 4 colonnes et 6 lignes dans la cellule `F0`.
Dans la cellule `F0` on tape par exemple :
`=tran([A0:A3,C0:C3])` pour avoir une matrice avec 2 colonnes et 4 lignes dans la cellule `F0`.
Dans la cellule `F0` on tape par exemple :
`=tran([A0:A3,B0:B3,C0:C3])` pour avoir une matrice avec 3 colonnes et 4 lignes dans la cellule `F0`.
Attention!!!
On ne peut pas remplir plusieurs cellules d’un seul coup avec une matrice contenant des références à d’autres cellules : quand il y a une formule faisant des références à d’autres cellules on ne peut remplir qu’une seule cellule et il faut mettre le signe `=` devant la formule.

## 1.4 Pour sauver l’écran du tableur

### 1.4.1 Pour sauver une matrice

Vous avez rempli l’écran du tableur avec une matrice.

Pour sauver cette matrice vous pouvez utiliser le bouton `Save` de la barre de boutons cela sauvera la matrice sous le nom inscrit dans la ligne d’état après `Spreadsheet` (en général le même nom que le nom du fichier sans son extension `.tab` ou vous pouvez utiliser le menu `Fich` sous-menu `Nom de variable` en donnant un autre nom de variable.

Pour sauver une sous-matrice, il faut la sélectionner soit avec la souris, soit en utilisant la case de sélection et ensuite utiliser le menu `Fich` sous-menu `Sauver selection vers variable` puis donner le nom de la variable qui stockera la matrice sélectionnée (cf 1.1.6).
La format est celui d’une matrice. On aura donc dans la variable designée une matrice par exemple : `[[1,2,3,4,5],[1,0,2,0,1],[...]]`

### 1.4.2 Pour sauver un tableur

Vous avez rempli un tableur avec différentes formules. Pour sauver ce tableur il suffit d’utiliser le bouton `sauver` de la barre de boutons ou on utilise le menu `Fich` sous-menu `Sauver comme` (cf 1.1.6).
Lorsque vous sauvez ainsi, vous sauvez à la fois les formules et les valeurs. En effet, le format de sauvetage est une matrice dont chaque coefficient est une liste de trois éléments : le premier élément est la formule qui définit la cellule, le deuxième élément est la valeur prise par la cellule et le troisième est une variable détat interne.
On aura par exemple `spreadsheet[[[3,3,2],[=A0+1,4,2]],[...]]`, cela vaut dire que `A0=3`, que `B0=A0+1` et que la valeur de `B0` est `4`.
Lors d’une évaluation du tableur, la troisième valeur vaut :
`0` si la cellule n’a pas encore été recalculée, `1` si la cellule est en cours de calcul,
`2` si la cellule a été calculée.

L’algorithme est le suivant :
1/ On fait toutes les cellules de la gauche vers la droite et du haut vers le bas,
2/ Si le troisième argument de la cellule vaut 2, c’est fini. Si le troisième argument de la cellule vaut 1, on envoie une erreur : "évaluation récursive",
3/ le troisième argument de la cellule vaut 0, on le met à 1 et on cherche toutes les cellules dépendant de cette cellule, on calcule leurs valeurs et on remplace puis, on met à 2 le troisième argument de la cellule.

## 1.5 Pour copier une partie du tableur dans une ligne d’enrée

### 1.5.1 Pour copier une seule cellule du tableur dans une ligne d’enrée

Il faut sélectionner la cellule à recopier avec la souris et se servir du bouton `copier` du tableur.
Puis, on met le curseur dans une ligne d’enrée, puis on appuie sur la touche `coller`, et la cellule est recopiée dans la ligne de commande.

### 1.5.2 Pour copier plusieurs cellules du tableur dans une ligne d’entrée

Si les cellules sont consécutives, on peut les sélectionner avec la souris, sinon on utilisera la `case de sélection`.
On tape par exemple dans la `case de sélection` :
`A0..3,D`
les quatre premières cellules des colonnes `A` et `D` sont alors sélectionnées.
Puis, on met le curseur dans une ligne de commande et on appuie sur la touche `coller`, et les quatre premières cellules des colonnes `A` et `D` sont recopiées dans la ligne de commande.

## 1.6 Les fonctions spécifiques du tableur

### 1.6.1 Tableau de valeurs de f(x) : `tablefunc`

On peut avoir, dans le tableur, le tableau des valeurs numériques d’une expression f(x) pour x=x0, x0+h, x0+2*h.... en tapant dans la ligne de commande du tableur :
`tablefunc(f(x),x,x0,h)` ou `tablefunc(f(x),x)`.
Après avoir selectionné `A0`, on tape, par exemple, dans la ligne de commande du tableur :

`tablefunc(x```^```2,x,-1,0.2)`

On obtient si on a 15 lignes :

`` | `A` | `B`
`0` | `x` | `x``2`
`1` | `0.2.0` | `"Tablefunc"`
`2` | `-1` | `1.0`
`3` | `-0.8` | `0.64`
`4` | `-0.6` | `0.36`
`..` | `..` | `..`
`14` | `1.4` | `1.96`

Dans le cas où les valeurs du point de départ `x0` et du pas `h` ne sont pas précisées, ces valeurs valent par défaut `x0=X-` et `h=((X+)-(X-))/10` où `X-` et `X+` sont définis dans la configuration du graphique (bouton rouge `geo`) et valent au démarrage `X-=-5.0` et `X+=5.0` et donc `x0=-5.0` et `h=1.0`.
On peut donc avoir aussi dans le tableur, les valeurs numériques des termes d’une suite un=f(n) pour n=n0, n0+1, n0+2,.... en tapant dans la ligne de commande du tableur :
`tablefunc(f(n),n,n0)`.
Après avoir selectionné `A0`, on tape, par exemple, dans la ligne de commande du tableur :

`tablefunc(n```^```2,n,5,1)`

On obtient si on a 15 lignes :

`` | `A` | `B`
`0` | `n` | `n``2`
`1` | `1.0` | `"Tablefunc"`
`2` | `5` | `25.0`
``
`3` | `6.0` | `36.0`
`4` | `7.0` | `49.0`
`..` | `..` | `..`
`14` | `17.0` | `289.0`

Remarque
Lorsque la colonne `A` est sélectionnée, `tablefunc(f(x),x,x0,h)` a pour effet de placer, dans la colonne `A` et à partir de la ligne `0` :
`x,h,x0,A2+A$1` et,
dans la colonne `B` et à partir de la ligne `0` :
`f(x),"Tablefunc",evalf(subst(B$0,A$0,A2))`

### 1.6.2 Termes d’une suite récurrente : `tableseq`

On peut avoir, dans le tableur, les valeurs numériques des termes d’une suite récurrente (`u``0``=u0, u``n``=f(u``n-1``)`) grâce à la commande :
`tableseq(f(n),n,u0)`.
Après avoir selectionné `A0`, on tape, par exemple, dans la ligne de commande du tableur :

`tableseq(0.5*(n+3/n),n,3)`

On obtient, si on a 7 lignes :

`` | `A`
`0` | `0.5*(n+3/n)`
`1` | `n`
`2` | `3`
`3` | `2`
`4` | `1.75`
`..` | `..`
`7` | `1.73205080757`

Après avoir selectionné `B0`, on tape, par exemple, dans la ligne de commande du tableur :

`tableseq(x+y,[x,y],[1,1])`

On obtient, les premiers termes de la suite de Fibonacci :

`` | `B`
`x+y` | ``
`1` | `x`
`2` | `y`
`3` | `1`
`4` | `1`
`5` | `2`
`..` | `..`
`7` | `5`
`..` | `..`

Remarque
Lorsque la colonne `E` est sélectionnée, `tableseq(f(n),n,u0)` a pour effet de placer, dans la colonne `E` et à partir de la ligne `0` :
`f(n),n,u0,evalf(subst(E$0,E$1,E2))`.

## 1.7 Références de la cellule active : `Row` et `Col`

`Row` et `Col` sont des fonctions qui sont utilisables essentiellement dans le tableur, en dehors du tableur `Row` et `Col` sont le numéro de la ligne et de la colonne de la cellule sélectionnée du dernier tableur évalué.
`Row` n’a pas des paramètre et renvoie le numéro de la ligne de la cellule courrante.
On tape quand la cellule `C4` est mise en surbrillance :
`Row()`
On obtient :
`4`
`Col` n’a pas des paramètre et renvoie le numéro de la colonne de la cellule courrante (la colonne `A` a pour numéro 0, la colonne `B` a pour numéro 1 etc...)
On tape quand la cellule `C4` est mise en surbrillance :
`Col()`
On obtient :
`3`
Ainsi si dans la cellule `A0` je mets :
`=Row()+Col()` puis je recopie cette formule vers le bas et j’obtiens :
dans la colonne `A` :
`0,1,2,3,4...`
puis je recopie cette formule vers la droite depuis `A0` et j’obtiens :
dans la ligne `0` :
`0,1,2,3,4...`
puis je recopie cette formule vers la droite depuis `A1` et j’obtiens :
dans la ligne `1` :
`1,2,3,4,5...` etc...
Attention Bien mettre le signe `=` car `Row()` et `Col()` font références à la ligne et à la colonne de la cellule dans laquelle se trouve la formule.

## 1.8 Nommer une cellule par une variable : `current_sheet`

`current_sheet` est une fonction qui est utilisable essentiellement dans le tableur, en dehors du tableur `current_sheet` permet d’avoir accès aux cellules du dernier tableur évalué.
`current_sheet` s’utilise soit avec :
- aucun paramètre : `current_sheet()` renvoie le tableur tout entier,
- un paramètre entier : `current_sheet(j)` renvoie la ligne `j` du tableur,
- deux paramètres entiers : `current_sheet(j,k)` renvoie la cellule du tableur située à la ligne `j` et à la colonne `k`.
Ainsi `current_sheet(3,1)` désigne la cellule `B3`.
Cela permet de désigner une cellule par deux variables entières, par exemple :
`j:=3;k:=1;current_sheet(j,k)`
Remarque
Pour avoir la colonne `k` du tableur dans une ligne de commande, il faut taper :
`tran(current_sheet())[k]` (puisque `tran(current_sheet())` désigne la transposée du tableur).
On peut bien sûr utiliser `current_sheet` dans le tableur.
On tape :
`=current_sheet(1,2)`
ou encore, on peut prendre la valeur d’une case comme indice :
si `A0` contient 1 et `B1` contient 2 on peut taper, `=current_sheet(A0,B1)`.
Exemple d’utilisation :
On tape la suite des nombres entiers dans la colonne `A`.
On tape dans `A0` :
`1`
puis on tape dans `A1` :
`=A0+1`
formule que l’on recopie avec avec le menu `Edit` du tableur, puis, `Remplir` et `Copier vers le bas`.
Dans la colonne `B` on met, par exemple, la suite un=∑k=0n(−1)k/(k+1).
On tape dans `B0` :
`1`
puis on tape dans `B1` :
`=B0+(-1)```^```A1/(A1+1)`, formule que l’on recopie avec le menu `Edit` du tableur, puis, `Remplir` et `Copier vers le bas`.
On veut extraire de cette suite, les termes d’indice pair dans la colonne `C`, on tape dans `C0` :
`=current_sheet(2*A0,1)`, formule que l’on recopie avec `remplir` et `vers le bas`.
On veut extraire de cette suite les termes d’indice impair dans la colonne `D`, on tape dans `D0` :
`=current_sheet(2*A0+1,1)`, formule que l’on recopie avec le menu `Edit` du tableur, puis, `Remplir` et `Copier vers le bas`.
Ou encore on utilise `Row` et on n’a besoin que de 3 colonnes .
On tape dans `A0` :
`1`
puis on tape dans `A1` :
`=A0+(-1)```^```Row()/(Row()+1)`, formule que l’on recopie avec le menu `Edit` du tableur, puis, `Remplir` et `Copier vers le bas`.
On veut extraire de cette suite, les termes d’indice pair dans la colonne `B`, on tape dans `B0` :
`=current_sheet(2*Row(),0)`, formule que l’on recopie avec `remplir` et `vers le bas`.
On veut extraire de cette suite les termes d’indice impair dans la colonne `C`, on tape dans `C0` :
`=current_sheet(2*Row()+1,0)`, formule que l’on recopie avec le menu `Edit` du tableur, puis, `Remplir` et `Copier vers le bas`.

## 1.9 Compter les éléments du tableur vérifiant une propriété

On suppose que dans la colonne `A` il y a `1,2,3,4`, dans la colonne `B` il y a `2,4,6,8` et dans la colonne `C` il y a `4,8,12,16`.
Attention !
Pour désigner une plage du tableur, on tape `A0:C3`, mais `Xcas` le raplatit en une liste : dans l’exemple ci-dessus `A0:C3=[1,2,2,4,3,6]` Remarque
Pour avoir une méthode rapide pour compter, par exemple, les sommes obtenues lorsqu’on lance 101 fois deux dés. On remplit aléatoirement les colonnes `A` et `B` en tapant `ranm(101,1)` comme valeur pour `A0` et `B0`. Il faut créer une cellule tampon, qui contiendra le tableau des valeurs de la zone à analyser. On place simplement dans cette cellule la definition de la plage précédée de =, par exemple si `A0` à `B100` contient des jets de deux dés, et que `C` contient la somme de la colonne `A` et de la colonne `B`, on met dans `D0` : `= C0:C100`.
Ensuite dans `D2` à `D12` on ecrit :
`=count_eq(2,D0)`... `count_eq(12,D0)`
Ainsi le calcul de la plage `C0:C100` qui est long n’est fait qu’une fois. C’est le meme principe qu’en programmation, on utilise une variable intermediaire (la cellule tampon `D0`).

### 1.9.1 Compter les éléments d’un sous tableau vérifiant une propriété : `count`

`count` a deux ou trois paramètres : une fonction réelle `f` et une liste ou un sous-tableau éventuellement un paramètre optionnel `row` ou `col`.
Attention dans le tableur les paramètre optionnels `row` ou `col` ne servent pas, car dans une ligne du tableur un sous-tableau (par exemple `A0:C3`) désigne une liste : en effet si dans une cellule on met `=A0:C3`, la cellule contient la liste obtenue en mettant les lignes du sous tableau `A0:C3` bout à bout.
Si vous voulez utiliser le sous tableau (par exemple `A0:C3`) comme une matrice il faut mettre dans une cellule `=list2mat(A0:C3),3)` (car `3` est le nombre de colonnes de `A0:C3`). On peut aussi sauver la sélection `A0:C3` vers une variable (menu `Table`), car lors de cette affectation la matrice n’est pas aplati et donc cette variable contient une matrice.
`count` applique la fonction aux éléments de la liste ou du sous-tableau et en renvoie la somme.
Si `f` est une fonction boolénne `count` renvoie le nombre d’éléments de la liste ou du sous-tableau pour lesquels la fonction boolénne est vraie.
On tape dans une cellule :

`=count((x)->x,A0:C3)`

On obtient :

`70`

En effet, la somme des éléments de `A0:C3` vaut `(1+2+3+4)*7=70` car dans A il y a 1,2,3,4 dans B il y a 2*A soit 2,4,6,8 et dans C il y a 4*A soit 4,8,12,16 donc en tout il y a 7*A.
On tape dans une cellule :

`=count((x)->(x<10 and x>5),A0:C3)`

On obtient :

`3`

En effet, il y a `6,8,8`, soit 3 éléments qui sont entre 5 et 10.

### 1.9.2 Compter les éléments ayant une valeur donnée : `count_eq`

`count_eq` a deux ou trois paramètres : une nombre et une liste réelle ou un sous-tableau et éventuellement un paramètre optionnel `row` ou `col`.
Attention dans le tableur les paramètre optionnels `row` ou `col` ne servent pas, car dans le tableur car un sous-tableau est aplati en une liste.
`count_eq` renvoie le nombre d’éléments de la liste ou du sous-tableau qui sont égaux au premier argument.
On tape dans une cellule :

`=count_eq(4,A0:C3)`

On obtient :

`3`

car dans A il y a 1,2,3,4 dans B il y a 2*A soit 2,4,6,8 et dans C il y a 4*A soit 4,8,12,16.

### 1.9.3 Compter les éléments plus petits qu’une valeur donnée : `count_inf`

`count_inf` a deux ou deux paramètres : une nombre et une liste réelle ou un sous-tableau et éventuellement un paramètre optionnel `row` ou `col`.
Attention dans le tableur les paramètre optionnels `row` ou `col` ne servent pas, car dans le tableur car un sous-tableau est aplati en une liste.
`count_inf` renvoie le nombre d’éléments de la liste (ou du sous-tableau qui sont strictement inférieurs au premier argument.
On tape dans une cellule :

`=count_inf(4,A0:C3)`

On obtient :

`4`

car dans A il y a 1,2,3,4 dans B il y a 2*A soit 2,4,6,8 et dans C il y a 4*A soit 4,8,12,16.

### 1.9.4 Compter les éléments plus grands qu’une valeur donnée : `count_sup`

`count_sup` a deux ou trois paramètres : une nombre et une liste réelle ou un sous-tableau et éventuellement un paramètre optionnel `row` ou `col`.
Attention dans le tableur les paramètre optionnels `row` ou `col` ne servent pas, car dans le tableur car un sous-tableau est aplati en une liste.
`count_sup` renvoie le nombre d’éléments de la liste ou du sous-tableau qui sont strictement supérieurs au premier argument.
On tape dans une cellule :

`=count_sup(4,A0:C3)`

On obtient :

`5`

car dans A il y a 1,2,3,4 dans B il y a 2*A soit 2,4,6,8 et dans C il y a 4*A soit 4,8,12,16.

## 1.10 Les fonctions statistiques à une variable du tableur

### 1.10.1 Les fonctions graphiques

On peut utiliser directement le graphique depuis le tableur : les fonctions graphiques peuvent être utilisées dans une cellule. Pour avoir l’histogramme, la boite à moustaches, un nuage de points ou une ligne polygonale depuis le tableur on peut se servir du menu `Maths` du tableur (puis `stats 1-d`) après avoir sélectionné dans le tableur l’argument avec la souris ou avec la `case de sélection`. Dans ce cas, une boite de dialogue s’ouvre, vous devez choisir la cellule cible (c’est dans cette cellule que s’inscrira la commande graphique), vous pouvez éventuellement modifier la sélection (en mettant par exemple `A1..B6` dans `cellules entrée`), vous pouvez cocher (resp ne pas cocher) `valeur` pour que la commande graphique ait pour argument les valeurs (resp les références) de la sélection : donc si `valeur` n’est pas cochée un changement de valeur dans une cellule de la sélection aura pour conséquence un changement du graphique, si on est en mode automatique ou si on appuie sur le bouton `eval`.
Ou encore, on peut taper la commande correspondante (ou se servir du menu `Math``▸``Proba_stats``▸``1-d`) dans la ligne de commande du tableur en recopiant les arguments en se servant de la souris (ou en se servant de la `case de sélection` et de la touche `coller` lorsque les colonnes que l’on veut recopier ne sont pas consécutives), ou encore on peut sauver la sélection dans une variable en utilisant le menu du tableur `Table``▸``Sauver sélection vers variable` on donne un nom par exemple `A`, puis on tape `moustache(A)` ou... Dans ce cas on travaille avec les valeurs de la sélection.

### 1.10.2 Centre d’un intervalle : `interval2center`

`interval2center` a comme argument un intervalle ou une liste (resp séquence) d’intervalles (utile pour définir les centres des classes).
`interval2center` renvoie le centre de l’intervalle ou la liste (resp séquence) des centres de ces intervalles.
`interval2center` est utile pour définir les centres des classes.
On tape :

`interval2center(3..5)`

On obtient :

`4`

On tape :

`interval2center([2..4,4..6,6..10])`

On obtient :

`[3,5,8]`

### 1.10.3 Centre d’un intervalle : `center2interval`

`center2interval` a comme argument un vecteur de réels `V` d’au moins deux composantes et éventuellement un réel comme deuxième argument.
`center2interval` renvoie un vecteur d’intervalles ayant pour centres les composantes de l’argument `V` : ces intervalles sont définis en commençant le premier intervalle, par le deuxième argument ou à défaut par `(3*V[0]-V[1])/2`.
`center2interval` est utile pour définir des classes à partir de leurs centres et du minimum des classes.
On tape :

`center2interval([3,5,8])`

Ou on tape car la valeur par défaut du deuxième argument est 2=(3*3-5)/2 :

`center2interval([3,5,8],2)`

On obtient :

`[2..4,4..6,6..10]`

On tape :

`center2interval([3,5,8],2.5)`

On obtient :

`[2.5..3.5,3.5..6.5,6.5..9.5]`

Attention
On ne peut pas mettre n’importe quoi comme deuxème argument!!!
On tape :

`center2interval([5,7,8],4)`

Ou on tape, car la valeur par défaut du deuxième argument est 4=(3*5-7)/2 :

`center2interval([5,7,8])`

On obtient :

`"center2interval Bad Argument Value"`

La fonction suivante peut vous permettre de trouver l’intervalle dans lequel il faut choisir le deuxème argument, quand il y a une solution!!!
En effet on doit pouvoir trouver a0,a1,a2... vérifiant :
a0<a1<a2.... et
a0+a1=2*c0=b0,a1+a2=2*c1=b1,a2+a3=2*c2=b2.... quand L=[c0,c1,c2...] avec c0<c1<c2....
On a donc :
a1=b0−a0,
a2=b1−a1=b1−b0+a0,
a3=b2−a2=b2−b1+b0−a0
a4=b3−a3 ...
comme on doit avoir a0<a1 et a1<a2 (c’est à dire a1<c1) il faut donc trouver a0 vérifiant a0<c0 et b0−c1<a0 puis
a2<a3 i.e. a0<c2−c1+c0 et
a3<a4 i.e.a3<c3 b0−b1+b2−c3<a0...
On construit donc deux listes :
`l1=[c0,c2-2*c1+2*c0...]` et
`l2=[2*c0-c1,2*c0-2*c1+2*c2-c3,..]`.
La condition que doit vérifier `a0` est alors :
`max(l1)<a0<min(l2)`.

    debut_classes(L):={
    local l1,l2, n,j, a, b;
    n:=size(L);
    L:=sort(L);
    l1:=[L[0]];
    l2:=[2*L[0]-L[1]];
    for (j:=1;2*j+1<n;j++) {
    l1:=concat(l1,l2[j-1]-L[2*j-1]+L[2*j]);
    l2:=concat(l2,l1[j]+L[2*j]-L[2*j+1]);
    }
    if (irem(n,2)==1) {
    j:=quo(n-1,2);
    l1:=concat(l1,l2[j-1]-L[2*j-1]+L[2*j]);
    }
    a:=max(l2);
    b:=min(l1);
    if (a<b) return(]a,b[); else return ("impossible");
    }

On tape :

`debut_classes([5,7,8])`

On obtient :

`]3,4[`

On tape :

`center2interval([5,7,8],3.5)`

On obtient :

`[3.5 .. 6.5,6.5 .. 7.5,7.5 .. 8.5]`

On tape :

`interval2center([3.5 .. 6.5,6.5 .. 7.5,7.5 .. 8.5])`

On obtient :

`[5.0,7.0,8.0]`

### 1.10.4 Somme des cellules d’un sous-tableau : `sum`

La commande `sum` permet de calculer la somme des éléments d’une liste.
Si on a une matrice ou un sous-tableau définie dans un tableur, on sait qu’en désignant ses éléments par :
"référence de la première case de la matrice" `:` "référence de sa dernière case de la matrice", on obtient la liste des éléments de la matrice (par ex `A0:B1` est la liste `[A0,B0,A1,B1]` formée par la matrice aplatie).
Attention
Pour traiter les exemples qui suivront, on remplit par exemple la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2`.
Pour cela on met `0` dans `A0`, et
`=A0```^```2` dans `B0`, `=A0+1` dans `A1` puis on utilise le bouton `remplir` et `vers le bas` pour recopier les 2 formules dans chacune des colonnes `A` et `B`.
Après avoir selectionné `C0`, on tape, par exemple, dans la ligne de commande du tableur :

`=sum(A0:B5)`

On obtient dans `C0` :

`70`

en effet : 1+2+3+4+5+1+4+9+16+25=3*5+5*11=70
Mais dans une ligne d’entrée, si on tape :
`sum([[0,0],[1,1],[2,4],[3,9],[4,16],[5,25]])`
On obtient :
`[15,55]`
qui est la somme des colonnes de la matrice.
Après avoir selectionné `D0`, on tape, par exemple, dans la ligne de commande du tableur :

`=sum(A0:B5)+B8`

On obtient dans `D0`:

`134`

en effet : 1+2+3+4+5+1+4+9+16+25+64=3*5+5*11+64=134

### 1.10.5 Somme de n cellules : `sum`

On tape dans `D0` :

`10`

On tape dans `D1` :

`=sum(current_sheet(j,1),j,1,D0)`

On obtient dans `D1` la somme des cellules `B1` à `B10` :

`385`

En effet `current_sheet(j,1)` désigne la cellule de la colonne `B` (colonne 1) et de la ligne `j` et puisque `j` varie de `1` à `D0` qui vaut `10`, donc dans `D1` on a la somme des cellules de `B1` à `B10`.

### 1.10.6 Moyenne des cellules d’un sous-tableau : `mean`

Si `mean` a comme argument une liste, `mean` calcule la moyenne des éléments de cette liste.
Si `mean` a comme argument deux listes, `mean` calcule la moyenne des éléments de la première listes, pondérés par les éléments de la seconde liste.
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4)
Remarque
Une cellule remplie avec une chaine de caractères vide n’est pas prise en compte : on peut ainsi faire les calculs sur les réponses effectives à un questionnaire, par exemple, et ainsi de ne pas tenir compte des questionnaires non complètement remplis.

#### Moyenne des cellules d’un sous-tableau d’effectif 1

La commande `mean` permet de calculer la moyenne de plusieurs cellules situées dans un sous-tableau.
Après avoir selectionné `C0`, on tape, par exemple, dans la ligne de commande du tableur :

`=mean(A0:B5)`

On obtient dans `C0` :

`35/6`

en effet : `A0:B5` désigne la liste `[0,0,1,1,2,4...,5,25]` `mean(A0:B5)` renvoie donc la valeur de :
(1+2+3+4+5+1+4+9+16+25)/12=70/12=35/6=5.83333333333.
Mais dans une ligne d’entrée, si on tape :
`mean([[0,0],[1,1],[2,4],[3,9],[4,16],[5,25]])`
On obtient :
`[5/2,55/6]`

#### Moyenne des cellules d’un sous-tableau avec effectifs

La commande `mean` permet de calculer la moyenne des valeurs de cellules situées dans un sous-tableau pondérée par un autre sous-tableau.
Après avoir selectionné `D0`, on tape, par exemple, dans la ligne de commande du tableur :

`=mean(A3:B5,A0:B2)`

On obtient dans `D0` :

`65/4`

en effet, `mean(A3:B5,A0:B2)` calcule :
(4*1+5*2+16*1+25*4)/(1+2+1+4)=130/8=65/4. Mais dans une ligne d’entrée, si on tape :
`mean([[3,9],[4,16],[5,25]],[[0,0],[1,1],[2,4]])`
On obtient :
`[14/3,116/5]`
En effet :
`mean([3,4,5],[0,1,2])=14/3`
`mean([9,16,25],[0,1,4])=116/5`
ce sont les moyennes des colonnes du premier argument pondérée par les colonnes du deuxième argument.
Après avoir selectionné `D0`, on tape, par exemple, dans la ligne de commande du tableur :

`=mean(A0:A5,B0:B5)`

On obtient dans `D0` :

`45/11`

en effet, `mean(A0:A5,B0:B5)` calcule :
(1*1+2*4+3*9+4*16+5*25)/(1+4+9+16+25)=45/11.

### 1.10.7 Écart-type des cellules d’un sous-tableau : `stddev`

Il y a deux cas :
Si `stddev` a comme argument une liste, `stddev` calcule l’écart-type des éléments de ce sous-tableau.
Si `stddev` a comme argument deux listes, `stddev` calcule l’écart-type des éléments de la première liste, pondérés par les éléments de la seconde liste.
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4)

#### Écart-type des cellules d’un sous-tableau d’effectif 1

La commande `stddev` permet de calculer l’écart type des valeurs de cellules situées dans un sous-tableau.
Après avoir selectionné `C1`, on tape, par exemple, dans la ligne de commande du tableur :

`=stddev(A0:B5)`

On obtient dans `C1` :

`sqrt(1877/36)`

Mais dans une ligne d’entrée, si on tape :
`stddev([[0,0],[1,1],[2,4],[3,9],[4,16],[5,25]])`
On obtient :
`[sqrt(35/12),sqrt(2849/36)]`

#### Écart-type des cellules d’un sous-tableau avec effectifs

La commande `stddev` permet de calculer l’écart-type des valeurs de cellules situées dans un sous-tableau pondérées par un autre sous-tableau.
Après avoir selectionné `D1`, on tape, par exemple, dans la ligne de commande du tableur :

`=stddev(A3:B5,A0:B2)`

On obtient dans `D1` :

`sqrt(1419/16)`

Mais dans une ligne d’entrée, si on tape :
`stddev([3,9],[4,16],[5,25]],[[0,0],[1,1],[2,4]])`
On obtient :
`[sqrt(2/9),sqrt(324/25)]`

#### Estimation de l’écart-type de la population mère : `stdDev`

`stdDev` a les mêmes arguments que `stddev`. Si le premier argument a comme dimension n, on a la relation :
`n:=size(L);stdDev(L)=stddev(L)*sqrt(n/(n-1))` La commande `stdDev` permet de calculer une estimation de l’écart-type de la population mère à partir d’un échantillon d’ordre n et dont les valeurs sont mises en argument.
Après avoir selectionné `C2`, on tape, par exemple, dans la ligne de commande du tableur :

`=stdDev(A0:B5)`

On obtient dans `C2` :

`sqrt(1877/33)`

ici n=6*2=12 et 12/11*1877/36=1877/33 Après avoir selectionné `D2`, on tape, par exemple, dans la ligne de commande du tableur :

`=stdDev(A3:B5,A0:B2)`

On obtient dans `D2` :

`sqrt(1419/14)`

ici n=8 et 8/7*1419/16=1419/14

### 1.10.8 Variance des cellules d’un sous-tableau : `variance`

Il y a deux cas :
Si `variance` a comme argument une liste, `variance` calcule la variance des éléments de cette liste.
Si `variance` a comme argument deux listes, `variance` calcule la variance des éléments de la première liste, pondérés par les éléments de la seconde liste. La variance est le carré de l’écart-type.
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4).

#### Variance des cellules d’un sous-tableau d’effectif 1

La commande `variance` permet de calculer la variance des valeurs de cellules situées dans un sous-tableau.
Après avoir selectionné `C2`, on tape, par exemple, dans la ligne de commande du tableur :

`=variance(A0:B5)`

On obtient dans `C2` :

`187/36`

#### Variance des cellules d’un sous-tableau avec effectifs

La commande `variance` permet de calculer la variance des valeurs de cellules situées dans un sous-tableau pondérée par un autre sous-tableau.
Après avoir selectionné `D2`, on tape, par exemple, dans la ligne de commande du tableur :

`=variance(A3:B5,A0:B2)`

On obtient dans `C6` :

`1419/16`

### 1.10.9 La médiane : `median`

Il y a deux cas :
Si `median` a comme argument une liste, `median` calcule la médiane des éléments de cette liste.
Si `median` a comme argument deux listes, `median` calcule la médiane des éléments de la première liste, pondérée par les éléments de la seconde liste.
La médiane est l’élement Me de la série à partir du lequel la fréquence cumulée de Me égale ou dépasse 0.5 (on appelle fréquence cumulée d’une valeur `a` la somme des fréquences de `t` pour toutes les valeurs `t ≤ a`)
Un sous-tableau est transformé en une liste quand on le désigne dans un tableur par :
"référence de sa première case" `:` "référence de sa dernière case".
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4).

#### Médiane des cellules d’un sous-tableau d’effectif 1

La commande `median` permet de calculer la médiane des valeurs de cellules situées dans un sous-tableau.
Après avoir selectionné `C3`, on tape, par exemple, dans la ligne de commande du tableur :

`=median(A0:A10)`

On obtient dans `C3` :

`5.0`

#### Médiane des cellules d’un sous-tableau avec effectifs

La commande `median` permet de calculer la médiane des valeurs de cellules situées dans un sous-tableau pondérée par un autre sous-tableau.
Après avoir selectionné `D3`, on tape, par exemple, dans la ligne de commande du tableur :

`=median(A0:A10,B0:B10)`

On obtient dans `C7` :

`8`

### 1.10.10 Le premier quartile : `quartile1`

Il y a deux cas :
Si `quartile1` a comme argument un sous tableau, `quartile1` calcule le premier quartile des éléments de ce sous-tableau.
Si `quartile1` a comme argument deux sous tableaux, `quartile1` calcule le premier quartile des éléments du premier sous-tableau, pondérés par les éléments du second sous-tableau.
Le premier quartile est l’élement Q1 de la série à partir du lequel la fréquence cumulée de Q1 égale ou dépasse 0.25.
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4).

#### Le premier quartile des cellules d’un sous-tableau d’effectif 1

La commande `quartile1` permet de calculer le premier quartile des valeurs de cellules situées dans un sous-tableau.
Après avoir selectionné `C4`, on tape, par exemple, dans la ligne de commande du tableur :

`=quartile1(A0:A10)`

On obtient dans `C4` :

`2.0`

#### Le premier quartile des cellules d’un sous-tableau avec effectifs

La commande `quartile1` permet de calculer le premier quartile des valeurs de cellules situées dans un sous-tableau pondérée par un autre sous-tableau.
Après avoir selectionné `D4`, on tape, par exemple, dans la ligne de commande du tableur :

`=quartile1(A0:A10,B0:B10)`

On obtient dans `D4` :

`7`

### 1.10.11 Le troisième quartile : `quartile3`

Il y a deux cas :
Si `quartile3` a comme argument un sous tableau, `quartile3` calcule le troisième quartile des éléments de ce sous-tableau.
Si `quartile3` a comme argument deux sous tableaux, `quartile3` calcule le troisième quartile des éléments du premier sous-tableau, pondérés par les éléments du second sous-tableau. Le troisième quartile est l’élement Q3 de la série à partir du lequel la fréquence cumulée de Q3 égale ou dépasse 0.75.
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4).

#### Le troisième quartile des cellules d’un sous-tableau d’effectif 1

La commande `quartile3` permet de calculer le troisième quartile des valeurs de cellules situées dans un sous-tableau.
Après avoir selectionné `C5`, on tape, par exemple, dans la ligne de commande du tableur :

`=quartile3(A0:A10)`

On obtient dans `C5` :

`8.0`

#### Le troisième quartile des cellules d’un sous-tableau avec effectifs

La commande `quartile3` permet de calculer le troisième quartile des valeurs de cellules situées dans un sous-tableau pondérées par un autre sous-tableau.
Après avoir selectionné `D5`, on tape, par exemple, dans la ligne de commande du tableur :

`=quartile3(A0:A10,B0:B10)`

On obtient dans `D5` :

`10`

### 1.10.12 Les valeurs indiquant la répartition : `quartiles`

Il y a deux cas :
Si `quartiles` a comme argument un sous tableau, `quartiles` calcule la matrice colonne contenant le minimum, le premier quartile, la médiane, le troisième quartile et le maximum des éléments de ce sous-tableau.
Si `quartiles` a comme argument deux sous tableaux, `quartiles` calcule la matrice colonne contenant le minimum, le premier quartile, la médiane, le troisième quartile et le maximum des éléments du premier sous-tableau, pondérés par les éléments du second sous-tableau.
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4).

#### Valeurs indiquant la répartition des cellules d’un sous-tableau d’effectif 1

La commande `quartiles` permet de calculer la matrice colonne contenant le minimum, le premier quartile, la médiane, le troisième quartile et le maximum des valeurs de cellules situées dans un sous-tableau.
Après avoir selectionné `C6`, on tape, par exemple, dans la ligne de commande du tableur :

`=quartiles(A0:A10)`

On obtient dans `C6` :

`[[0.0],[2.0],[5.0],[8.0],[10.0]]`

#### Valeurs indiquant la répartition des cellules d’un sous-tableau avec effectifs

La commande `quartiles` permet de calculer la matrice colonne contenant le minimum, le premier quartile, la médiane, le troisième quartile et le maximum des valeurs de cellules situées dans un sous-tableau pondérées par un autre sous-tableau.
Après avoir selectionné `D6`, on tape, par exemple, dans la ligne de commande du tableur :

`=quartiles(A0:A10,B0:B10)`

On obtient dans `D6` :

`[[1.0],[7.0],[8.0],[10.0],[10.0]]`

## 1.11 Les fonctions statistiques à deux variables du tableur

### 1.11.1 Les fonctions graphiques

On peut utiliser directement le graphique depuis le tableur : toutes les fonctions graphiques peuvent être utilisées dans une cellule. Pour avoir un nuage de points on utilise `scatterplot` et pour tracer une ligne polygonal on utilise `polygonplot`.
Depuis le tableur, on peut se servir du menu du tableur `Statistiques``▸``2-d` et remplir la boite de dialogue correspondant à l’item choisi : vous devez choisir la cellule cible (c’est dans cette cellule que s’inscrira la commande graphique), vous pouvez éventuellement modifier la sélection (en mettant par exemple `A1..B6` dans `cellules entrée`), vous pouvez cocher (resp ne pas cocher) `valeur` pour que la commande graphique ait pour argument les valeurs (resp les références) de la sélection : donc si `valeur` n’est pas cochée un changement de valeur dans une cellule de la sélection aura pour conséquence un changement du graphique, si on est en mode automatique ou si on appuie sur le bouton `eval`.
Ou bien, dans la ligne de commande du tableur ou dans une ligne de commande, on utilise `scatterplot` et `polygonplot` du menu `Math``▸``Stats``▸``2-d` et on recopie les arguments en les sélectionnant, soit en se servant de la souris (ou de la `case de sélection` et de la touche `coller` lorsque les colonnes que l’on veut recopier ne sont pas consécutives), soit on sauve cette sélection avec le menu du tableur `Fich``▸``Sauver sélection vers variable`, on donne un nom par exemple `A`, puis on tape `polygonplot(A)` ou `scatterplot(A)`: dans ce cas on travaille avec les valeurs de la sélection.

### 1.11.2 La covariance avec effectif 1 : `covariance`

`covariance` calcule la covariance numérique de plusieurs cellules situées dans deux sous-tableaux de même dimension.
Si `T`=tj est le premier argument et `B`=bj le deuxième argument, la covariance `covariance(T,B)` est alors définie par :
cov(T,B)=1/N∑j(tj−mT)(bj−mB)
où mT (resp mB) est la moyenne des éléments tj de `T` (resp bj de `B`) et N le nombre d’éléments de `T`.
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4).
On tape lorsque `C0` est en surbrillance :

`=covariance(A1:A4,B1:B4)`

On obtient dans `C0` :

`25/4`

Dans une ligne d’entrée, on tape :

`covariance([1,2,3,4],[1,4,9,16])`

Ou on tape :

`covariance([[1,1],[2,4],[3,9],[4,16]])`

On obtient :

`25/4`

### 1.11.3 La corrélation linéaire avec effectif 1 : `correlation`

`correlation` calcule la corrélation linéaire numérique de plusieurs cellules situées dans deux sous-tableaux de même dimension.
Si `T`=tj est le premier argument et `B`=bj le deuxième argument, la corrélation `correlation(T,B)` est alors : cov(T,B)/σ(T) σ(B)
où σ(T) (resp σ(B)) est l’écart-type des éléments de `T` (resp `B`) et cov(T,B) est la covariance de `T` et de `B`.

Dans le tableur
Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4).
On tape lorsque `C1` est en surbrillance :

`=correlation(A1:A4,B1:B4)`

On obtient dans `C1` :

`25/sqrt(645)`

on a en effet :
`covariance(A1:A4,B1:B4)=25/4`,
`stddev(A1:A4)=sqrt(5)/2` et,
`stddev(B1:B4)=sqrt(129)/2`
et `129*5=645`

Dans une ligne d’entrée
On tape :

`correlation([1,2,3,4],[1,4,9,16])`

Ou on tape :

`correlation([[1,1],[2,4],[3,9],[4,16]])`

On obtient :

`25/sqrt(645)`

### 1.11.4 La covariance et la corrélation linéaire avec effectifs : `covariance` et `correlation`

- Si les couples a[j],b[j] ont pour effectif n[j] (j=0..p−1), `covariance` (resp `correlation`) a pour argument trois listes a, b, n de même longueur p, ou une matrice composée trois colonnes a, b, n et de p lignes [a[j],b[j],n[j]].
  `covariance` (resp `correlation`) calcule la covariance (resp corrélation) numérique des deux premières listes pondérées par la liste donnée comme dernier argument ou des deux colonnes de cette matrice pondérées par la troisiéme colonne.
  Dans une ligne d’entrée
  On tape dans une ligne d’entrée :
  `covariance([1,2,3,4],[1,4,9,16],[3,1,5,2])`
  Ou on tape :
  `covariance([[1,1,3],[2,4,1],[3,9,5],[4,16,2]])`
  On obtient :
  `662/121`
  On tape dans une ligne d’entrée :
  `correlation([1,2,3,4],[1,4,9,16],[3,1,5,2])`
  Ou on tape :
  `correlation([[1,1,3],[2,4,1],[3,9,5],[4,16,2]])`
  On obtient :
  `662/(180*sqrt(14))`
  Dans le tableur
  On remplit les colonnes `A,B,C`.
  On tape dans `A0` :
  `[[1,1,3],[2,4,1],[3,9,5],[4,16,2]]`
  On tape dans `D0` :
  `=covariance(list2mat(A0:C3,3))`
  On obtient dans `D0` :
  `662/121`
  On tape dans `D1` :
  `=correlation(list2mat(A0:C3,3))`
  On obtient dans `E1` :
  `662/(180*sqrt(14))`
- Si les couples a[j],b[k] ont pour effectif N[j,k] lorsque j=0..p−1 et k=0..q−1, `covariance` (resp `correlation`) a pour argument deux listes a, b de longueurs respectives p et q et une matrice N de p lignes et q colonnes.
  `covariance` (resp `correlation`) calcule la covariance (resp corrélation) numérique des éléments de deux listes pondérés par un tableau donné comme troisième argument.

Exercice
Soient `X=[1,2]`, `Y=[11,13,14]` et `N=[[3,4,5],[12,1,2]]`.
Calculer la covariance et la corrélation de `X,Y` sachant qu’il y a `N`= Nj,k couples Xj,Yk.
Dans une ligne d’entrée
On tape :

`covariance([1,2],[11,13,14],[[3,4,5],[12,1,2]])`

On obtient :

`-83/243`

On tape :

`correlation([1,2],[11,13,14],[[3,4,5],[12,1,2]])`

On obtient :

`-83/160`

On a :
`simplify(stddev([1,2],[12,15]))=2*sqrt(5)/9`
`simplify(stddev([11,13,14],[15,5,7]))=16*sqrt(5)/27`
et on a bien :
`-83/243=-83/160*(sqrt(20)/9)*(16*sqrt(5)/2)`
Dans le tableur
On peut disposer les données selon un tableau à double entrée à condition de rajouter `-1` comme dernier argument aux fonctions `covariance` et `correlation`.
On tape :
dans `A0` :
"X\ Y" (c’est pour l’esthétique)
dans `A1` :
1
dans `A2` :
2
dans `B0,C0,D0` :
`11,13,14`
dans `B1,C1,D1` :
`3,4,5`
dans `B2,C2,D2` :
`12,1,2`
Calcul de la covariance ou de la corrélation dans le tableur :
On tape dans `E0` :

`=covariance(list2mat(A0:D2,4),-1)`

On obtient dans `E0` :

`-83/243`

On tape dans `E1` :

`=correlation(list2mat(A0:D2,4),-1)`

On obtient dans `E1` :

`-83/160`

Remarque
On peut bien sûr faire le même calcul dans une ligne d’entrée :
On sélectionne avec la souris `A0..2,B,C,D`, puis on tape :
`covariance(,-1)`
puis, on met le curseur à l’endroit de l’argument manquant, puis on appuie sur coller, ou on tape :

`covariance([["x\y",11,13,14], [1,3,4,5],[2,12,1,2]],-1)`

On obtient :

`-83/243`

On tape :

`correlation([["x\y",11,13,14], [1,3,4,5],[2,12,1,2]],-1)`

On obtient :

`-83/160`

Attention
Dans une cellule du tableur on ne peut pas désigner un sous-tableau ou une matrice par :
"référence de la première case de la matrice" `:` "référence de sa dernière case de la matrice".
en effet si dans la cellule `C0` on tape :
`=A0:B4` et on obtient dans la cellule `C0` la liste :
`[A0,B0,A1,B1,A2,B2]` c’est à dire la matrice "aplatie".
Pourtant, si les couples `A`=a[j] et `B`=b[j] ont pour effectif `N`=n[j] (j=0..p−1), la covariance (resp la corrélation) de `A,B` avec effectifs `N` peuvent se calculer dans une ligne d’entrée, mais aussi dans le tableur même si les données ne figurent pas dans des colonnes consécutives.
Lorsque les colonnes sont consécutives, on peut reconstituer la matrice en utilisant `list2mat`, par exemple si on met les valeurs de `A` dans la colonne `A`, les valeurs de `B` dans la colonne `B` et les effectifs `N` dans la colonne `C` on tape dans la cellule `E1` `=list2mat(A0:C5,6,3)` et on obtient dans la cellule `E1` la matrice cherchée ayant 6 lignes et 3 colonnes `A,B,C`.
Lorsque les colonnes ne sont pas consécutives par exemple si on met les effectifs `N`=n[j] dans la colonne `D` on tape alors pour avoir une matrice dans la cellule `E1` :
`=tran([A0:A5,B0:B5,D0:D5])` et on obtient dans la cellule `E1` la matrice cherchée ayant 6 lignes et 3 colonnes `A,B,D`.

### 1.11.5 La régression linéaire : `linear_regression`

Pour approcher les données par la droite des moindres carrés qui a pour équation y=mx+b, on utilise `linear_regression`.
`linear_regression` a les mêmes arguments que `covariance`.
Si `linear_regression` a comme argument la liste `X` des xj et la liste `Y` des yj, `linear_regression` renvoie (m, b) tel que y ≃ m*x+b.
Pour traiter une régression linéaire à 2 ou plusieurs variables on se reportera à la section 1.11.8.

Avec le tableur Pour traiter les exemples, on remplit la colonne `A` par `0,1,2,..,n` et la colonne `B` par `0,1,4,..,n```^```2` (cf 1.10.4).
Puis, on tape dans la case `C0` :

`linear_regression(A1:A4,B1:B4)`

On obtient dans la case `C0` :

`5,-5`

Dans une ligne d’entrée
On tape :

`linear_regression([[1,1],[2,4],[3,9],[4,16]])`

Ou on tape

`linear_regression([1,2,3,4],[1,4,9,16])`

On obtient :

`(5,-5)`

ce qui veut dire que y=5x−5 est la droite qui approche au mieux les points de coordonnées : (1,1),(2,4),(3,9),(4,16).
Remarques

- La deuxième droite de régression
  Si on tape (on échange X et Y) :
  `linear_regression([1,4,9,16],[1,2,3,4])`
  Ou on tape :
  `linear_regression([[1,1],[4,2],[9,3],[16,4]])`
  On obtient la deuxième droite de régression :
  `25/129,45/43`
  On tape :
  `evalf(25/129,45/43)`
  On obtient :
  `(0.193798449612,1.04651162791)`
- Ajustement linéaire et corrélation linéaire
  Si R2 est le carré du coefficient de corrélation linéaire de X et de Y si m1 (resp m2) est la pente de la première (resp deuxième) droite de régression linéaire on a :
  `R2=m1*m2`
  On tape :
  `normal(correlation([1,2,3,4],[1,4,9,16])```^```2)`
  On obtient :
  `125/129`
  On tape :
  `5* 25/129`
  On obtient :
  `125/129`
  On tape :
  `evalf(125/129)`
  On obtient :
  `0.968992248062`

Autre exemples On suppose que l’on a les couples (xj,yj) avec :
x=[0,1,2,3,4,5,6,7,8,9,10] et
y=[7.3,9.53,12.47,16.3,21.24,27.73,36.22,47.31,61.78,80.68,105]
On tape :

`X:=[0,1,2,3,4,5,6,7,8,9,10]`
`Y:=[7.3,9.53,12.47,16.3,21.24,27.73,36.22,`
`47.31,61.78,80.68,105]`
`Z:=log(Y)`
`linear_regression(X,Z)`

On obtient :

`(0.266729219953,1.98904252589)`

c’est donc la fonction linéaire d’équation z=ln(y)=0.267*x+1.99 qui approche au mieux les données.
On suppose qu’il y a nj couples (xj,yj) avec :
x=[1,2,3,4], y=[1,4,9,16], et n=[3,1,5,2]
On tape :

`linear_regression([1,2,3,4],[1,4,9,16],[3,1,5,2])`

On obtient :

`(331/70, -22/5)`

c’est donc la fonction linéaire d’équation y=331*x/70−22/5 qui approche au mieux les données.
On suppose qu’il y a nj,k couples (xj,yk) avec :
x=[1,2], y=[11,13,14], et n=[[3,4,5],[12,1,2]]
On tape :

`linear_regression([1,2],[11,13,14],[[3,4,5],[12,1,2]])`

Ou on tape :

`linear_regression([["x\y",11,13,14],[1,3,4,5], [2,12,1,2]],-1)`

On obtient :

`(-83/60,143/10)`

c’est donc la fonction linéaire d’équation y=−83*x/60+143/10 qui approche au mieux les données. On calcule le coefficient de corrélation On tape :

`normal(correlation([1,2],[11,13,14],[[3,4,5],[12,1,2]])```2```)`

On obtient :

`6889/25600`

Donc R2 ≃ 0.2691015625 ce qui ne justifie pas un ajustement linéaire.

### 1.11.6 Ajustement linéaire et corrélation linéaire

Si R2 est le carré du coefficient de corrélation linéaire de X et de Y si m1 (resp m2) est la pente de la première (resp deuxième) droite de régression linéaire on a :

`R2=m1*m2`

On sait que le coefficient de correlation est un réel entre -1 et 1 donc 0 ≤ R2 ≤ 1. La valeur de R2 va nous dire si la forme du nuage de points justifie un ajustement lineaire. Il y a une forte corrélation linéaire lorsque √1−R2 ≤ 0.5 i.e. lorsque R2 ≥ 0.75.
On a :

- Si R2=0, l’ajustement lineaire n’est pas justifié
  cela n’exclut pas une dépendance entre X et Y l’ensemble des points M−j,k peut être voisin d’une courbe, mais l’ensemble des points ne peut pas être ajusté par une droite,
- Si R2<0.75, l’ajustement lineaire est bon
- Si R2 ≥ 0.75, l’ajustement lineaire n’est pas bon
- Si R2=1 les points sont alignés et les deux droites de régression sont confondues.

### 1.11.7 Le graphe de la régression linéaire : `linear_regression_plot`

Pour dessiner la droite des moindres carrés : la droite qui approche au mieux les données et qui a pour équation y=mx+b, on utilise `linear_regression_plot`.
`linear_regression_plot` a les mêmes arguments que `covariance`.
On tape :

`linear_regression_plot([1,2,3,4],[1,4,9,16],[3,1,5,2])`

On obtient :

`Le graphe de la droite d’équation` `y=331*x/70-22/5` `ou` `y=4.3*x-4.4` `et` `R2=0.966`

c’est donc la fonction linéaire d’équation y=331*x/70−22/5 qui approche au mieux les données.

### 1.11.8 La régression linéaire à 2 ou plusieurs variables

#### Le principe

Supposons que l’on observe 3 variables `(X,Y,Z)`, et que l’on veut savoir comment `Z` dépend linéairement de `X` et de `Y`.
On a par exemple observé n triplés xj,yj,zj pour j=0..n−1. On cherche c,a,b pour que le plan z=a*x+b*y+c approche au mieux les données.
Posons E=∑j=0n−1 (zj−a*xj−b*yj−c)2.
On cherche c,a,b pour que E soit minimum c’est à dire pour que :
∂ E/∂ a=−2*∑j=0n−1 xj*(zj−a*xj−b*yj−c)=0
∂ E/∂ b=−2*∑j=0n−1 yj*(zj−a*xj−b*yj−c)=0
∂ E/∂ c=−2*∑j=0n−1 (zj−a*xj−b*yj−c)=0
On a donc à résoudre un système de 3 équations à 3 inconnues c,a,b.
Soit U la matrice de n lignes et 3 colonnes ayant comme ligne j : [1,xj,yj] avec j=0..n−1.
Le système à résoudre est :
[

n | ∑xj | ∑yj
∑xj | ∑xj2 | ∑xjyj
∑yj | ∑xjyj | ∑yj2

] [

c
a
b

] = [

∑zj
∑xj zj
∑yj zj

] =`tran(U)` [

z0
....
zn−1

]

On remarque que la matrice associée au système précédent s’écrit :

`A=tran(U)*U`= | ⎡ ⎢ ⎢ ⎣ |  |
n | ∑xj | ∑yj
∑xj | ∑xj2 | ∑xjyj
∑yj | ∑xjyj | ∑yj2
|  | ⎤ ⎥ ⎥ ⎦

La solution c,a,b du système est donc : `inv(A)*tran(U)*Z`

#### Avec le tableur

Suppopsons que l’on a mis les données, dans le tableur (par exemple n=192) comme ceci :
- en `A` une colonne remplit avec des `1`,
- en `B` une colonne remplit avec les xj et représentant `X`,
- en `C` une colonne remplit avec les yj et représentant `Y`,
- en `D` une colonne remplit avec les zj et représentant `Z`.
Dans la case de sélection on marque :
`A0..A191,B,C`
On utilise le menu du tableur `Fich` `blacktriangleright` `Sauver selection vers variable` et on tape `U` comme nom de variable. Cela définira la matrice `U` égale à la sélection.
Puis, on met dans la case de sélection `D0..D191` et on utilise à nouveau le menu du tableur `Fich` `blacktriangleright` `Sauver selection vers variable` et on tape `Z` comme nom de variable. Cela définira le vecteur `Z` égale à la sélection.
On définit `A` en tapant : `A:=tran(U)*U`
Il ne reste plus qu’à taper dans une ligne de commande :
`(c,a,b):=col(inv(A)*tran(U)*Z,0)`
pour définir `c,a,b`.
Remarque
Bien sûr il faut que la matrice `A=tran(U)*U` soit inversible !!!!
On peut aussi taper :
`B:=border(A,op(-tran(Z)*U))` puis
`C:=rref(B)`, puis résoudre `C*[[c],[a],[b]]=0`.

### 1.11.9 La régression exponentielle : `exponential_regression`

Pour approcher les données par une fonction exponnentielle qui a pour équation y=b*exp(m*x)=b*ax, on utilise `exponential_regression`.
`exponential_regression` a les mêmes arguments que `covariance`.
Si `exponential_regression` a comme argument la liste `X` des xj et la liste `Y` des yj, `exponential_regression` renvoie (a, b) tel que y ≃ bax.
On tape dans la case `C1` :

`evalf(exponential_regression(A1:A4,B1:B4))`

ou on tape dans une ligne d’entrée :

`exponential_regression([[1.0,1],[2,4],[3,9],[4,16]])`

On obtient :

`2.49146187923,0.5`

On tape dans une ligne d’entrée :

`exponential_regression([0,1,2,3,4,5,6,7,8,9,10],[7.3, 9.53,12.47,16.3,21.24,27.73,36.22,47.31,61.78,80.68,105])`

On obtient :

`(1.30568684451, 7.30853268031)`

c’est donc la fonction expopnentielle d’équation :
y=7.30853268031*(1.30568684451)x qui approche au mieux les données.
Remarque
On a :
exp(0.266729219953,1.989042525894)=(1.30568684451, 7.30853268031)

### 1.11.10 Le graphe de la régression exponentielle : `exponential_regression_plot`

Pour dessiner la fonction exponnentielle qui a pour équation y=b*exp(m*x)=b*ax, et qui approche au mieux les données, on utilise `exponential_regression_plot`.
`exponential_regression_plot` a les mêmes arguments que `covariance`.
On tape dans l’écran `geo` :

`exponential_regression_plot([0,1,2,3,4,5,6,7,8,9,10],[7.3, 9.53,12.47,16.3,21.24,27.73,36.22,47.31,61.78,80.68,105])`

On obtient :

`Le graphe de la fonction expopnentielle d’équation` `y=7.30853268031*(1.30568684451)``x`

car c’est la fonction expopnentielle d’équation :
y=7.30853268031*(1.30568684451)x qui approche au mieux les données.

### 1.11.11 La régression logarithmique : `logarithmic_regression`

Pour approcher les données par une fonction logarithmique qui a pour équation y=m lnx+b, on utilise `logarithmic_regression`.
`logarithmic_regression` a les mêmes arguments que `covariance`.
Si `logarithmic_regression` a comme argument la liste `X` des xj et la liste `Y` des yj, `logarithmic_regression` renvoie (m, b) tel que y ≃ m *lnx+b.
On tape dans la case `C2` :

`evalf(logarithmic_regression(A1:A4,B1:B4))`

ou on tape dans une ligne d’entrée :

`evalf(logarithmic_regression([[1,1],[2,4],[3,9],[4,16]]))`

ou on tape dans une ligne d’entrée :

`logarithmic_regression([[1.0,1],[2,4],[3,9],[4,16]])`

On obtient :

`10.1506450002,-0.564824055818`

c’est donc la fonction logarithme d’équation :
y=10.1506450002ln(x)−0.564824055818
qui approche au mieux les données.

### 1.11.12 Le graphe de la régression logarithmique : `logarithmic_regression_plot`

Pour dessiner le graphe de la fonction logarithmique qui a pour équation y=m lnx+b, et qui approche au mieux les données, on utilise `logarithmic_regression_plot`.
`logarithmic_regression_plot` a les mêmes arguments que `covariance`.
On tape dans l’écran `geo` :

`logarithmic_regression_plot([[1.0,1],[2,4],[3,9],[4,16]])`

On obtient :

`Le graphe de la fonction logarithme d’équation` `y=10.1506450002` `ln``(x)-0.564824055818`

car c’est la fonction logarithme d’équation :
y=10.1506450002ln(x)−0.564824055818
qui approche au mieux les données.

### 1.11.13 La régression polynomiale : `polynomial_regression`

Pour approcher les données par une fonction polynomiale d’équation y=a0xn+..+an, on utilise `polynomial_regression`.
`polynomial_regression` a les mêmes arguments que `covariance`.
Si `polynomial_regression` a comme arguments la liste des xj, la liste des yj et le degré n du polynôme, `polynomial_regression` renvoie [an,..., a0]) tel que y ≃ an*xn+....+a0.
On tape dans le tableur :

`evalf(polynomial_regression(A1:A4,B1:B4,3))`

ou on tape dans une ligne d’entrée :

`evalf(polynomial_regression([[1,1],[2,4],[3,9],[4,16]],3))`

ou on tape dans une ligne d’entrée :

`polynomial_regression([[1.0,1],[2,4],[3,9],[4,16]],3)`

On obtient :

`[0.0,1.0,0.0,0.0]`

c’est donc le polynôme d’équation y=x2 qui approche au mieux les données.

### 1.11.14 La régression puissance : `power_regression`

Pour approcher les données par une fonction puissance d’équation y=bxm, on utilise `power_regression`.
`power_regression` a les mêmes arguments que `covariance`.
Si `power_regression` a comme argument la liste des xj et la liste des yj, `power_regression` renvoie (m, b) tel que y ≃ bxm.
On tape dans le tableur :

`evalf(power_regression(A1:A4,B1:B4))`

ou on tape ddans une ligne d’entrée :

`evalf(power_regression([[1,1],[2,4],[3,9],[4,16]]))`

ou on tape dans une ligne d’entrée :

`power_regression([[1.0,1],[2,4],[3,9],[4,16]])`

On obtient :

`[2.0,1.0]`

c’est donc la fonction puissace d’équation y=1*x2 qui approche au mieux les données.

### 1.11.15 Le graphe de la régression puissance : `power_regression_plot`

Pour approcher les données par une fonction puissance d’équation y=bxm, on utilise `power_regression_plot`.
`power_regression_plot` a les mêmes arguments que `covariance`.
On tape dans l’écran `geo` :

`power_regression_plot([[1.0,1],[2,4],[3,9],[4,16]])`

On obtient :

`Le graphe de la fonction puissace d’équation` `y=1*x``2`

car c’est la fonction puissace d’équation y=1*x2 qui approche au mieux les données.

## 1.12 Définition de fonctions de `Xcas`

### 1.12.1 Définition de fonction de répartition

Définition
On appelle fonction de répartition d’une variable aléatoire x sur l’espace probabilisé Ω la fonction F définie pour tout x réel par :

F(x)=Prob(X≤ x)

Propriétés

- F est croissante,
- limx−>−∞=0,
- limx−>+∞=1,
- Prob(a< X≤ b)=F(b)−F(a).

Définition
On dit qu’une variable aléatoire X est absolument continue si et seulement si il existe une fonction f, appelée densité de probabilité de X, telle que :

F(x)= | ∫ |
x
−∞
| f(t)dt

### 1.12.2 Les fonctions de répartition et de répartition inverse

Règle
Le nom de la fonction de répartition d’une loi est le nom de la loi, suivi par `_cdf`, et pour la fonction de répartition inverse par `_icdf` : `cdf` =cumulated distribution function = fonction de répartition.
Les premiers paramètres sont les paramètres de la loi et le dernier paramètre le nom de la variable.
On définit les fonctions suivantes :
`normald(t)` par exp(−(t2)/2)/√2*pi
`normald(``µ,σ``,t)` par 1/σ√2πexp(−1/2((t−µ)/σ)2)
`normal_cdf(x)`= Proba(X≤ x) avec X∈ N(0,1) : c’est la fonction de répartition de la loi normale centrée réduite.
`normal_icdf(t)` =h équivaut à Proba(X≤ h)=t avec X∈ N(0,1) : c’est l’inverse de la fonction de répartition de la loi normale centrée réduite.
`normal_cdf(``µ,σ``,x)`=Proba(X≤ x) avec X∈ N(µ,σ) : c’est la fonction de répartition de la loi normale de moyenne µ et d’écart-type σ.
`normal_icdf(``µ,σ``,t)` =h équivaut à Proba(X≤ h)=t avec X∈ N(µ,σ) : c’est l’inverse de la fonction de répartition de la loi normale de moyenne µ et d’écart-type σ.
`normal_cdf(a,b)`=`normal_cdf(b)-normal_cdf(a)`
`normal_cdf(``µ,σ``,a,b)`=`normal_cdf(``µ,σ``,b)-normal_cdf(``µ,σ``,a)`
`binomial(n,k,p)=comb(n,k)*p```^```k*(1-p)```^```n-k`
`binomial_cdf(n,p,x)`=Proba(X ≤ x) avec X∈ B(n,p) : c’est la fonction de répartition de la loi binomiale de paramètre n,p c’est à dire de moyenne np et d’écart-type √np(1−p).
`binomial_icdf(n,p,t)`= h équivaut à Proba(X≤ h)=t avec X∈ B(n,p) : c’est l’inverse de la fonction de répartition de la loi binomiale de paramètres n et p c’est à dire de moyenne np et d’écart-type √np(1−p).
`poisson(m,k)= exp(-m)*m```^```k/k!`
`poisson_cdf(``µ``,x)`=Proba(X≤ x) avec X∈ P(µ) : c’est la fonction de répartition de la loi de Poisson de paramètre µ, c’est à dire de moyenne µ et d’écart-type µ.
`poisson_cdf(``µ``,x1,x2)=poisson_cdf(``µ``,x2)-poisson_cdf(``µ``,x1)`
`poisson_icdf(``µ``,t)`= h équivaut à Proba(X≤ h)=t avec X∈ P(µ) : c’est l’inverse de la fonction de répartition de la loi de Poisson de paramètre µ, c’est à dire de moyenne µ et d’écart-type µ.
`student_cdf(n,x)`=Proba(X≤ x) avec X∈ T(n) : c’est la fonction de répartition de la loi de Student ayant n degrés de liberté.
`student_icdf(n,t)`=h équivaut à Proba(X≤ h)=t avec X∈ T(n) : c’est l’inverse de la fonction de répartition de la loi de Student ayant n degrés de liberté.
`chisquare_cdf(n,x)`=Proba(X≤ x) avec X∈ χ2(n) : c’est la fonction de répartition de la loi du χ2 ayant n degrés de liberté.
`chisquare_icdf(n,t)`=h équivaut à Proba(X≤ h)=t avec X∈ χ2(n) : c’est l’inverse de la fonction de répartition de la loi du χ2 ayant n degrés de liberté.
`fisher_cdf(n,k,x)`=`snedecor_cdf(n,k,x)`=Proba(X≤ x) lorsque X∈ F(n,k) : c’est la fonction de répartition de la loi de Fisher ayant n,k degrés de liberté.
`fisher_icdf(n,k,t)`=`snedecor_icdf(n,k,t)`=h ce qui veut dire que Proba(X≤ h)=t avec X∈ F(n,k) : c’est l’inverse de la fonction de répartition de la loi de Fisher ayant n,k degrés de liberté.
`UTPC,UTPF,UTPN,UTPT` avec `C` pour χ2, `F` pour Fisher, `N` pour Normale et `S` pour Student représentent le complément à 1 de la fonction de répartition correspondante.
Par exemple :
`UTPN(x)=1-normal_cdf(x)`
Mais attention : `UTPN(``µ ,σ``2``,x)=1-normal_cdf(``µ ,σ``,x)`