# Guide Pratique de Maxima Online 2

## Introduction

Maxima Online 2 est une interface web en français pour le système de calcul formel Maxima. Il est basé sur le projet Yamwi de Leo Butler. L'interface présente des menus déroulants permettant l'accès rapide à la plupart des commandes Maxima (sous forme d'exemples). Des assistants pour les graphiques sont également disponibles (courbes 2D, surfaces 3D, courbes et surfaces paramétriques).

Maxima Online 2 permet d'effectuer toutes sortes de calculs mathématiques et graphiques grâce à Maxima, sans que l'installation du logiciel soit nécessaire sur votre ordinateur. Il suffit d'avoir accès à un navigateur web et à une connexion Internet pour utiliser Maxima Online 2.

Pour l'utiliser, il suffit d'écrire une commande Maxima dans la zone de texte et de cliquer sur le bouton Exécuter. Le résultat de la commande s'affiche alors dans la page html générée par le logiciel. Il est possible de choisir le type de sortie pour les résultats fournis par Maxima :

- Affichage en ASCII-ART : sortie formatée uniquement avec des caractères ASCII
- Affichage en ASCII-ART étendu : sortie formatée avec le jeu complet des caractères ASCII
- Affichage Syntaxique : la sortie est formatée avec les notations d'entrée de Maxima
- Affichage TeX+Matjax : la sortie est formatée en utilisant TeX et Mathjax

Au lancement du logiciel, quelques exemples sont proposés qui peuvent être exécutés directement. Le bouton Effacer réinitialise la zone de texte. Les menus situés au dessus de la zone de texte permettent d'insérer rapidement des commandes Maxima courantes, constituées d'exemples qui peuvent être ensuite modifiés selon les besoins. Les 4 derniers boutons donnent accès à des assistants pour les graphiques, respectivement pour les courbes 2D, les surfaces 3D, les courbes paramétriques et les surfaces paramétriques. Concernant ces assistants, tous les champs obligatoires repérés par * doivent être remplis pour que le code Maxima soit généré. Il reste ensuite soit à cliquer sur le bouton Insérer dans l'éditeur pour insérer le code correspondant dans la zone de texte. Il est aussi possible de copier ce code à l'aide du bouton Copier.
Attention, on rappelle que les titres des graphiques Maxima ne doivent pas contenir de caractères spéciaux, comme des guillemets ou des apostrophes. Il est conseillé de remplacer ces caractères par des espaces, des underscores (_) ou de les supprimer.

En bas de la page, les boutons

- Enregistrer en PDF : sauvegarde la copie d'écran au format PDF
- Sauvegarder les commandes (.mac) : la zone de texte est sauvegardée dans un fichier .mac
- Charger des commandes (.mac) : le contenu d'un fichier .mac du disque est inséré dans la zone de texte
- Enregistrer batch pour wxMaxima : le contenu de la zone de texte est adapté puis sauvegardé dans un fichier .mac, destiné à être importé dans wxMaxima via la commande batch (traiter un fichier) pour exécution automatique.
- Importer un fichier wxm : permet d'importer des fichiers créés par wxMaxima, avec conversion automatique des commandes.
- Importer un fichier wxmx : permet d'importer des fichiers créés par wxMaxima dernières versions.
- Retour haut de page : permet de remonter au début de la page d'accueil.

En dessous de ces boutons, on trouve aussi

- Un bouton Générer le PDF, qui créé un document avec les commandes utilisées et leurs résultats.
- Après la génération de ce PDF, les nouveaux boutons Voir le PDF et Télécharger le PDF sont disponibles pour accéder au document généré.
- Le bouton Exporter en LateX permet de récupérer sous forme compressée (format zip) le document LaTeX ayant permis la génération du PDF, en y incluant les graphiques lorsqu'ils existent.

Une documentation basique, issue de l'aide du logiciel Yamwi (version initiale https://sourceforge.net/projects/yamwi/ dont l'auteur est Mario Rodríguez Riotorto) complété par une mise à jour complète du logiciel par Leo Butler : https://github.com/leo-butler/yamwi, est proposée ci-dessous. Elle se présente sous forme de dialogue, sachant que les commandes sont précédées par %i (suivi du numéro de l'entrée) et les réponses sont numérotées %o (suivi du même numéro).
Important : les commandes Maxima doivent se terminer par un point-virgule (;) ou un dollar ($) pour être exécutées.
Le site https://maxima-french-doc.fr/ fournit une documentation plus complète en français sur Maxima.

## Sommaire

- Nombres
  - Entiers
  - Nombres rationnels
  - Nombres complexes
  - Facteurs de conversion
- Algèbre
  - Polynômes
  - Équations
  - Inéquations
  - Vecteurs
  - Matrices
- Calcul
  - Limites
  - Dérivées
  - Intégrales
  - Équations différentielles
- Graphiques
  - Graphiques 2D
  - Graphiques 3D
  - Multigraphes
  - Animations
- Statistiques

## Nombres

###
Entiers

Vous pouvez utiliser des nombres entiers aussi grands que nécessaire. Voici la factorielle de 100,

    100!;

Comme dans tout autre langage de programmation, vous pouvez additionner (+), soustraire (-), multiplier (*), diviser (/), élever à une puissance (^), et calculer des racines carrées (sqrt).

    3^4 * (5-91+(-24)) + 75 / sqrt(25);

Connaissons la liste des diviseurs d'un entier donné et factorisons-le en nombres premiers,

    /* nous attribuons d'abord la variable a au nombre */
    a: 169996284$
    divisors(a);
    factor(a);

Demandons à Maxima si 1502933 est un nombre premier.

    primep(1502933);

Nous utilisons gcd pour calculer le plus grand commun diviseur de deux nombres, et lcm pour le plus petit commun multiple d'un ensemble arbitraire de nombres, mais tenez compte du fait que pour lcm nous devons d'abord charger le package functs.

    gcd(16479936, 43375500000);

    load("functs")$
    lcm(16479936,43375500000,111375);

La fonction divide retourne une liste avec deux éléments, le quotient et le reste (modulo) d'une division entière.

    divide(34, 5);

###
Nombres rationnels

Maxima aime les résultats exacts. Voici des opérations rationnelles. Les phrases doivent se terminer par un point-virgule (;).

    1+5*(5-7/9)^4;

Mais il est également possible d'obtenir des approximations en virgule flottante. Ici, nous stockons dans la variable x (avec un deux-points :) une expression rationnelle, puis nous appelons la fonction float.

    x: 1+5*(5-7/9)^4;
    float(x);

Le même résultat peut être obtenu avec une seule phrase.

    float(1+5*(5-7/9)^4);

Un autre exemple avec des variables. Puisque les commentaires sont écrits entre les symboles /* et */, voici un exemple auto-explicatif.

    /* Associer la variable 'a' à une valeur */
    a : 8 / 24;

    /* Associer la variable 'b' à une autre valeur */
    b: 1/5;

    /* Élever au carré la somme de 'a' et 'b' */
    (a+b)^2;

La fonction float retourne des nombres en double précision. Calculons le nombre π avec cinq mille décimales. Tout d'abord, nous donnons à la variable globale fpprec la précision souhaitée, puis nous appelons la fonction bfloat. Rappelez-vous que le symbole Maxima pour π est %pi. Nous calculons également la racine carrée de 2 avec 5000 décimales.

    fpprec : 5000;
    bfloat(%pi);

    /* La racine carrée de deux */
    bfloat(sqrt(2));

###
Nombres complexes

L'unité imaginaire est représentée par %i. Avec ce symbole, nous pouvons écrire n'importe quel nombre complexe et effectuer des opérations avec eux.

    z1: 3+5*%i;
    z2: 2/3 - %i;

    z1+z2;
    z1-z2;

Parfois, Maxima retourne des expressions complexes avec des parenthèses. Si nous voulons simplifier ces expressions, nous pouvons appeler la fonction expand.

    z1: 3 + 5*%i$
    z2: 2/3 - %i$

    3*z1 - 7*z2;
    expand(3*z1 - 7*z2);

    z1 * z2;
    expand(z1 * z2);

Nous pouvons transformer des nombres complexes sous forme binomiale en forme polaire et vice-versa.

    z: 3 + 5*%i;
    p: polarform(z);
    b: rectform(p);

Divisons deux nombres complexes et donnons le résultat sous forme binomiale,

    d: (3 + 5*%i) / (7/8 - 1/4*%i);
    rectform(d);

Étant donné un nombre complexe, nous pouvons obtenir ses parties réelle et imaginaire, ainsi que son module et son angle.

    z: 7/8 - 1/4*%i;
    realpart(z);
    imagpart(z);
    cabs(z);
    carg(z);

###
Facteurs de conversion

Le package ezunits fournit tout ce dont nous avons besoin pour les conversions d'unités. Voici quelques exemples.

    load("ezunits")$

    /* convertir m/s en km/h */
    5`m/s`km/hour;

    /* convertir N/cm^2 en Pa */
    32`N/cm^2`Pa;

    /* convertir m en inch en deux étapes */
    d : 10`m$
    d``inch;

    /* lister tous les facteurs de conversion */
    for k in known_unit_conversions do print(k)$

Vous pouvez déclarer vos propres facteurs de conversion.

    load("ezunits")$

    declare_unit_conversion(
        Pa = 9.869 * 10^-6 * atm,
        bar = 100000 * Pa)$

    5.3`atm`bar;

Nous pouvons convertir n'importe quelle unité physique en unités fondamentales.

    load("ezunits")$

    f: 7`kg*km/minute^2;

    /* me dire les dimensions */
    dimensions(f);

    /* me dire les unités fondamentales */
    fundamental_units(f);

    /* faire la conversion */
    f``fundamental_units(f);

## Algèbre

###
Polynômes

Nous pouvons effectuer des opérations avec des variables. Voyez comment nous transformons des expressions algébriques.

    1+x+5*y-2/3*x+y+2;

    (5*x^2*u*r)/(u^2*t);

Développement de produits.

    expand((x+1)^2*(x+5)*(x-a));

Factorisation de polynômes.

    factor(u^6 - 14*u^5 - 23*u^4 + 808*u^3 - 320*u^2 - 12800*u);

Utilisez la fonction subst si vous voulez calculer la valeur numérique d'une expression algébrique. Les crochets dans Maxima sont très importants, car nous pouvons construire des listes avec eux.

    f: 6.67*10^-11*m1*m2/r^2;

    subst([m1 = 4, m2 = 5, r = 7], f);
    subst([m1 = mass, m2 = mass], f);

###
Équations

En général, nous utilisons la fonction solve. Deux arguments sont nécessaires, la liste des équations suivie de la liste des inconnues.

Une équation linéaire simple.

    solve([5*(x+1/2)=1+x/3],[x]);

Équation linéaire avec paramètre.

    solve([5*(x+1/2)=k+x/3],[x]);

Une équation quadratique. Rappelez-vous que sqrt est la racine carrée et %i est le symbole Maxima pour l'unité imaginaire.

    solve([2*x^2 - 3*x + 5 = 0], [x]);

Un système d'équations. Nous pouvons éditer plus d'une ligne pour entrer une phrase. Nous appelons également le résultat en virgule flottante.

    sol : solve([5*x + y/8 = 4, x^2 = y],
        [x, y]);

    float(sol);

Lorsque les méthodes algébriques sont impossibles à appliquer, nous pouvons utiliser des routines numériques. La bibliothèque mnewton peut résoudre des équations et des systèmes d'équations par la méthode de Newton. Nous appelons la fonction mnewton avec trois arguments : la liste des équations, la liste des inconnues et les coordonnées du point de départ.

    load("mnewton")$

    /* équation avec une seule inconnue */
    mnewton([2*a^a = 5],[a],[1]);

    /* inconnues multiples */
    mnewton([2*3^u-v/u-5 = 0, u+2^v = 4], [u, v], [2, 2]);

###
Inéquations

La résolution des inéquations nécessite le package fourier_elim. Résolvons d'abord une inéquation linéaire avec une seule inconnue. La fonction fourier_elim a besoin de deux arguments, la liste des inéquations et la liste des inconnues.

Une inéquation de degré quatre.

    load("fourier_elim")$

    fourier_elim([x^4-5*x^2+4>0], [x]);

Un système d'inéquations avec une inconnue.

    load("fourier_elim")$

    fourier_elim(
        [(x+2)/4 <= x/2-3,
        (8-x)/3 < (1+x)/2-1],
        [x]);

Un système d'inéquations avec deux inconnues.

    load("fourier_elim")$

    des1: 3*x - 5*y < 2;
    des2: x+y > (1+x)/3;
    des3: y < 2;
    fourier_elim([des1, des2, des3], [x, y]);

###
Vecteurs

Les vecteurs sont représentés comme des listes avec des crochets. Nous pouvons effectuer avec eux plusieurs opérations courantes.

    v1: [1, 2, 3]$
    v2: [a, b, c]$

    /* addition et soustraction */
    v1 + v2;
    v1 - v2;

    /* multiplication par un nombre */
    k * v1;

    /* multiplication point */
    v1 . v2;

La multiplication vectorielle est définie dans le package vector3d.

    load(vector3d)$
    cross([a, b, c], [x, y, z]);

Voici un exemple de définition d'une nouvelle fonction dans Maxima. Nous voulons écrire une fonction pour calculer le module d'un vecteur ; voyez que les fonctions sont définies au moyen de l'opérateur :=. Ne vous inquiétez pas si vous ne comprenez pas la partie interne de la fonction.

    modulus(v):= sqrt(apply("+", v^2))$
    modulus([a, 5, c]);

###
Matrices

La fonction matrix construit des matrices ; ses arguments sont les lignes de la matrice sous forme de liste. Nous définissons deux matrices puis nous les additionnons et les soustrayons.

    a : matrix([1, 2, 3], [4, 5, 6]);
    b : matrix([7, 1/9, 2], [z, x+y, -5]);

    a + b;
    a - b;

L'opérateur pour le produit matriciel est le point (.).

    a : matrix([1, 2, 3], [4, 5, 6]);
    b : matrix([7, 1/9], [z, -5], [1, 0]);

    a . b;

L'opérateur pour l'exponentiation matricielle est ^^.

    a : matrix([1, 2, 3], [4, 5, 6], [7, 8, 9]);
    a^^3;

D'autres opérations avec les matrices.

    a : matrix([1, 4, 3], [7, 5, 6], [3, 8, 9]);

    /* Inverse */
    invert(a);

    /* Transposée */
    transpose(a);

    /* Déterminant */
    determinant(a);

Il existe certaines matrices spéciales, comme les matrices identité et nulles.

    ident(4);
    zeromatrix(4,2);

Étant donnée une matrice, nous calculons son polynôme caractéristique, ses valeurs propres et ses vecteurs propres.

    A: matrix([1,3], [5,7]);

    /* le deuxième argument est le nom de la variable */
    charpoly(A, x);

    /* les valeurs propres et leurs multiplicités */
    eigenvalues(A);

    /* les valeurs propres et leurs vecteurs correspondants */
    eigenvectors(A);

## Calcul

###
Limites

La fonction limit permet de calculer des limites.

L'infini est représenté par inf et moins l'infini par minf.

    f: (x-1)/(2*x+3);

    /* x approche 1 */
    limit(f, x, 1);

    /* x approche l'infini positif */
    limit(f, x, inf);

    /* x approche l'infini négatif */
    limit(f, x, minf);

Vous pouvez approximer la limite par la droite ou par la gauche.

    g: 1/(x-1);
    limit(g, x, 1);

    /* approche de 1 par la droite */
    limit(g, x, 1, plus);

    /* approche de 1 par la gauche */
    limit(g, x, 1, minus);

###
Dérivées

Nous devons appeler la fonction diff.

    fun: sin(x)*x^4;

    diff(fun, x);

Calcul des dérivées d'ordre supérieur à un.

    /* ordre trois */
    diff(log(x)*x^x, x, 3);

Si nous voulons calculer des dérivées implicites, nous devons indiquer à Maxima quelles variables dépendent de la variable indépendante.

    /* y est une constante */
    i: x^4-x*y=cos(y^2+x);
    diff(i, x);

    /* maintenant, y dépend de x */
    depends(y, x)$
    diff(i, x);

###
Intégrales

Nous appelons integrate pour les intégrales indéfinies et définies.

    /* intégrale indéfinie */
    integrate(sin(2+3*x), x);

    /* intégrale définie */
    integrate(x*exp(x), x, 1, 2);

Lorsque les méthodes symboliques ne peuvent pas être appliquées, nous pouvons utiliser certaines routines numériques. L'une d'elles est quad_qag ; elle nécessite cinq arguments, l'intégrande, la variable indépendante, les deux limites d'intégration, et un entier entre 1 et 6, qui est un paramètre de la procédure (3 est un bon choix). Ce que nous obtenons est une liste de nombres, le premier est la valeur de l'intégrale définie, et le second est une estimation de l'erreur.

    quad_qag(exp(sin(x)), x, 2, 7, 3);

###
Équations différentielles

Lors de la résolution d'équations différentielles, nous devons indiquer à Maxima quelle variable dépend de la variable indépendante. Nous devons appeler la fonction ode2 afin de résoudre les équations différentielles ordinaires.

    depends(y, x)$

    /* une équation avec variables séparées */
    e: (x-1)*y^3+(y-1)*x^3*diff(y,x)=0;
    r: ode2(e,y,x);

    /* appliquer les conditions initiales */
    ic1(r,x=2,y=-3);

Résolution d'une équation différentielle de type Bernoulli.

    depends(y, x)$
    r: ode2(diff(y,x)-y+sqrt(y),y,x);

    /* isoler la variable dépendante avec solve */
    solve(r, y);

Ensemble avec la fonction ode2, le package contrib_ode ajoute plus de capacités pour résoudre les équations différentielles, veuillez consulter la documentation disponible.

Résolution d'une équation différentielle du second ordre, à savoir l'équation du mouvement harmonique simple.

    depends(x, t)$

    e: diff(x,t,2) + 3*x = 0;
    r: ode2(e, x, t);

    /* appliquer les conditions initiales */
    ic2(r, t=0, x=1, diff(x,t)=1/2);

    /* ou appliquer les conditions aux limites */
    s: bc2(r, t=0, x=1, x=3, t=-1);

    /* traçons-la ! */
    draw2d(explicit(rhs(s), t, 0, 10))$

Avec la fonction desolve, nous pouvons résoudre des systèmes d'équations différentielles, mais dans ce cas, nous devons indiquer explicitement les dépendances des fonctions.

    desolve(
        [diff(f(x),x)=3*f(x)-2*g(x),
        diff(g(x),x)=2*f(x)-2*g(x)],
        [f(x),g(x)]);

Si nous voulons appliquer des conditions initiales, nous devons les déclarer avec atvalue avant d'appeler desolve.

    atvalue(f(x),x=0,-1)$
    atvalue(g(x),x=0,3)$
    atvalue(h(x),x=0,1)$

    desolve(
        [diff(f(x),x)=f(x)+g(x)+3*h(x),
        diff(g(x),x)=g(x)-2*h(x),
        diff(h(x),x)=f(x)+h(x)],
        [f(x), g(x), h(x)]);

Lorsque les méthodes symboliques ne sont pas autorisées, nous pouvons utiliser la méthode de Runge-Kutta (rk). Ici, nous traçons également la fonction résultante.

    /* résolution de dy/dt = 2 y^2-exp(-3 t) */
    sol: rk(2*y^2-exp(-3*t), y, 0, [t, 0, 10, 0.2])$

    draw2d(
        points_joined = true,
        points(sol))$

## Graphiques

La meilleure référence pour le package draw est le document html Une interface Maxima-Gnuplot, qui contient de nombreux exemples. Vous pouvez trouver plus d'exemples dans le manuel de Maxima.

###
Graphiques 2D

Les dessins 2D sont réalisés avec la fonction draw2d.

Les options sont écrites sous la forme option = valeur et les objets graphiques sous la forme objet(arg1, arg2, ...).

Voici une fonction explicite en rouge. Les fonctions explicites nécessitent une expression, le nom de la variable indépendante et les extrémités du domaine à tracer.

    draw2d(
        color = red,
        explicit(x^3-2*x^2+x-1, x, -3, 3))$

Les options sont lues séquentiellement et affectent les objets déclarés après elles. Voici une fonction explicite avec une fonction paramétrique. Une grille est ajoutée en arrière-plan.

    draw2d(
        explicit(x^3-2*x^2+x-1, x, -3, 3),
        grid = true,
        color = red,
        line_width = 4,
        parametric(sin(t), t^2, t, -2*%pi, 2*%pi))$

Nous pouvons tracer des points isolés et des lignes polygonales. Les points de coordonnées peuvent être passés à l'objet points sous forme de liste de paires, en écrivant la liste des abscisses suivie de la liste des ordonnées, ou en donnant uniquement la liste des ordonnées. Voyez aussi que les couleurs peuvent être déclarées sous forme hexadécimale, et comment les styles de points, à l'exception de la couleur, affectent les deux derniers objets.

    draw2d(
        /* style par défaut */
        points([[2,3], [7,4], [0,5], [5,2/3], [7,-1], [8,3], [-2,10]]),

        point_type = circle,
        point_size = 3,
        color = brown,
        points_joined = true,
        points([3,4,6,8],[-2,-5,3,1]),

        color = "#ff670d",
        points([2, 6, 2, 8, 9]))$

Une fonction implicite, une fonction définie en coordonnées polaires et un polygone.

    draw2d(
        /* options globales */
        title = "Écrivez ici votre titre",
        xlabel = "axe x",
        ylabel = "axe y",
        grid = true,
        dimensions = [500,500],

        /* fonction implicite */
        key = "Implicite",
        implicit(y^2=x^3-2*x+1, x, -4,4, y, -4,6),

        /* coordonnées polaires */
        key = "Polaire",
        color = red,
        polar(10/theta, theta, 1,3*%pi),

        /* polygone */
        key = "Polygone",
        fill_color = sea_green,
        color = aquamarine,
        line_width = 6,
        polygon([[1,1],[3,0],[4,5],[0,3]]))$

###
Graphiques 3D

Les dessins 3D sont réalisés avec la fonction draw3d.

Une surface en fil de fer.

    draw3d(
        explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$

Surface cachée avec des lignes rouges.

    draw3d(
        surface_hide = true,
        color = red,
        explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$

Surface colorée en fonction des coordonnées des points.

    draw3d(
        color = blue,
        enhanced3d = true,
        explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$

Fixons le nombre de nœuds à calculer.

    draw3d(
        nsteps = 100,
        mesh_lines_color = blue,
        explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$

Une courbe paramétrique. Voyez comment la couleur dépend du paramètre u.

    draw3d(
        line_type = solid,
        line_width = 3,
        color = green,
        parametric(5*cos(u),5*sin(u),u,u,0,8*%pi))$

Points et lignes dans l'espace.

    xx: [1,2,3,4,5]$
    yy: [4,5,7,1,2]$
    zz: [3,2,1,9,4]$
    xyz: [[10,15,12],[11,13,16],[16,10,11],[15,15,15]]$

    draw3d(
        point_type = filled_square,
        color = blue,
        points(xx,yy,zz),
        point_type = circle,
        color = green,
        points_joined = true,
        points(xyz))$

Une surface définie en coordonnées sphériques.

    draw3d(
        color = green,
        surface_hide = true,
        axis_3d = false,
        xtics = none,
        ytics = none,
        ztics = none,
        title = "Nautile",
        spherical(a+z,a,0,3*%pi,z,0,%pi))$

Famille de surfaces définies en coordonnées cylindriques.

    draw3d(
        proportional_axes = xyz,
        dimensions = [500,500],
        surface_hide = true,
        axis_3d = false,
        xtics = none,
        ytics = none,
        ztics = none,
        color = blue,
        cylindrical(z,z,-2,2,a,0,2*%pi), /* cône */
        color = brown,
        cylindrical(3,z,-2,2,a,0,%pi), /* cylindre */
        color = green,
        cylindrical(sqrt(25-z^2),z,-5,5,a,0,%pi) /* sphère */)$

###
Multigraphes

Pour dessiner plusieurs scènes indépendantes, vous devez appeler la fonction draw, en passant autant de graphiques 2D et 3D que nécessaire, avec les objets gr2d et gr3d, respectivement. Voici un exemple simple, où nous fixons les dimensions selon nos besoins.

    draw(
        dimensions = [400,600],
        gr2d(
            color = red,
            explicit(sin(x), x, -5, 5)),
        gr3d(
            color = black,
            surface_hide = true,
            explicit(sin(x)*cos(y), x, -5, 5, y, -5, 5)))$

Par défaut, les graphiques multiples sont disposés en une seule colonne, mais vous pouvez changer ce comportement avec l'option columns.

    draw(
        columns = 2,
        dimensions = [600,300],
        gr2d(
            color = red,
            explicit(sin(x), x, -5, 5)),
        gr3d(
            color = black,
            surface_hide = true,
            explicit(sin(x)*cos(y), x, -5, 5, y, -5, 5)))$

Ce dernier exemple montre comment tracer une scène à l'intérieur d'une autre. L'option allocation nécessite une liste de deux paires de nombres : les coordonnées du coin inférieur gauche de la scène, et sa largeur et hauteur ; toutes les valeurs doivent être relatives, de 0 à 1.

    draw(
        dimensions = [500,400],
        gr2d(
            background_color = cyan,
            color = red,
            explicit(x^2, x, -1, 1)),
        gr2d(
            allocation = [[0.30,0.50],[0.50,0.40]],
            background_color = green,
            explicit(x^3, x, -1, 1),
            grid = true))$

###
Animations

Pour les animations, nous devons utiliser la fonction draw et définir terminal = animated_gif.

    draw(
        terminal = animated_gif,
        delay = 40,
        dimensions = [300,300],
        makelist(gr2d(explicit(x^(k/10),x,0,1)), k, 1, 10))$

## Statistiques

Les fonctions statistiques sont définies dans le package descriptive et nous devons les charger avant d'effectuer nos calculs.

Les graphiques statistiques définis dans le package descriptive doivent être écrits avec la première lettre en majuscule : Scatterplot, Histogram, Barsplot, Piechart, Boxplot, et Starplot.

Nos enregistrements ici sont stockés dans une liste.

    load(descriptive)$
    sample:
    [4, 7, 6, 1, 5, 10, 3, 6, 6, 6, 9, 9, 5, 2,
    2, 7, 7, 4, 6, 7, 8, 4, 10, 10, 4]$

    mean(sample);
    median(sample);

    /* écart-type */
    std(sample);

    /* diagramme circulaire */
    Piechart(sample)$

En cas d'enregistrements bivariés, les paires sont introduites sous forme de matrice à deux colonnes.

    load(descriptive)$
    sample:
    matrix(
        [125.1,140.7], [130.6,155.1], [135.1,160.3],
        [140.0,167.2], [145.4,169.8], [142.7,168.5])$

    /* vecteur moyen */
    mean(sample);

    /* vecteur de covariance */
    cov(sample);

    /* matrice de corrélations */
    cor(sample);

    /* nuage de dispersion */
    draw2d(
        point_type = circle,
        point_size = 3,
        color = navy,
        points(sample))$

Mario Rodríguez Riotorto