<TeXmacs|1.0.0.8>

<style|<tuple|article|maxima>>

<\body>
  <\expand|make-title>
    <title|Introduction à Maxima>

    <author|Richard H. Hand (Université de Cornell)>

    <name|Traduction française : Michel Gosse>

    <\address>
      <\with|paragraph mode|center>
        email : michel.gosse@ac-poitiers.fr\ 
      </with>

      <with|font|palatino|<with|paragraph mode|center|Version 1.0 du 30 avril
      2002>>
    </address>
  </expand>

  Cet article est la traduction en français du document d'introduction sur
  Maxima, écrit par Richard Hand, de l'Université de Cornell.

  Ce document a été produit par le logiciel <TeXmacs> (voir
  <verbatim|http://www.texmacs.org>), qui s'interface avec Maxima et permet
  une présentation en notation mathématique standard des résultats produits
  par ce logiciel de calcul formel.

  <\expand|table-of-contents|toc>
    <vspace*|1fn><with|font series|<quote|bold>|Table des
    matières><value|toc-dots><pageref|toc-1><vspace|0.5fn>

    <vspace*|1fn><with|font series|<quote|bold>|1<space|2spc>Introduction><va\
    lue|toc-dots><pageref|toc-2><vspace|0.5fn>

    <vspace*|1fn><with|font series|<quote|bold>|2<space|2spc>Les touches et
    les symboles spéciaux><value|toc-dots><pageref|toc-3><vspace|0.5fn>

    <vspace*|1fn><with|font series|<quote|bold>|3<space|2spc>Arithmétique><va\
    lue|toc-dots><pageref|toc-4><vspace|0.5fn>

    <vspace*|1fn><with|font series|<quote|bold>|4<space|2spc>Algèbre><value|t\
    oc-dots><pageref|toc-5><vspace|0.5fn>

    <vspace*|1fn><with|font series|<quote|bold>|5<space|2spc>Calcul
    différentiel><value|toc-dots><pageref|toc-6><vspace|0.5fn>

    <vspace*|1fn><with|font series|<quote|bold>|6<space|2spc>Calcul
    matriciel><value|toc-dots><pageref|toc-7><vspace|0.5fn>

    <vspace*|1fn><with|font series|<quote|bold>|7<space|2spc>Programmer avec
    Maxima><value|toc-dots><pageref|toc-8><vspace|0.5fn>

    <vspace*|1fn><with|font series|<quote|bold>|8<space|2spc>Une liste
    partielle des fonctions Maxima><value|toc-dots><pageref|toc-9><vspace|0.5\
    fn>
  </expand>

  <section|Introduction>

  Pour lancer Maxima sous Windows, double-cliquer sur le fichier xmaxima, qui
  est situé dans le sous-répertoire d'installation du logiciel. Sous Linux,
  on peut taper dans une console soit maxima, ce qui lance le logiciel en
  mode texte, soit xmaxima, qui le lancera en mode graphique. Dans tous les
  cas, on obtient un message ressemblant à :

  <\session|maxima|default>
    <\output>
      GCL (GNU Common Lisp) \ Version(2.4.0) Wed May \ 9 12:02:00 CDT 2001

      Licensed under GNU Library General Public License

      Contains Enhancements by W. Schelter

      Maxima 5.6 Wed May 9 12:01:49 CDT 2001 (with enhancements by W.
      Schelter).

      Licensed under the GNU Public License (see file COPYING)

      \;
    </output>

    <\input|<\with|color|red>
      (C1) <with|color|black|>
    </with>>
      \;
    </input>
  </session>

  (C1) est une étiquette. Chaque entrée ou sortie est numérotée et on peut
  s'y référer par son étiquette durant toute une session maxima. Le C indique
  une entrée ( Command ), et le D une sortie ( Display ). Il ne faudra donc
  jamais employer de variables telles que C1 ou D5, car cela prêtera à
  confusion.

  Maxima ne distingue pas les caractères en majuscule et en minuscule; Si
  vous entrez sin(x) ou SIN(x), cela désignera la fonction sinus pour le
  logiciel. Par contre, pour les réponses qu'il renvoie, le logiciel
  emploiera systématiquement une notation en majuscule. Cette règle ne
  s'applique pas aux variables définies par l'utilisateur; par exemple, les
  variables x et X sont distinctes pour Maxima. Testez-le ...

  <section|Les touches et les symboles spéciaux>

  <\expand|enumerate-numeric>
    <\with|line stretch|0.3cm>
      <\with|line stretch|0cm>
        <item>Pour arrêter une session maxima, taper
        <with|font|pandora|quit();>. Si vous tapez CTRL C, alors voici ce que
        Maxima va afficher :\ 

        <\code>
          Correctable error : Console interrupt

          Signalled by Macysgma-top-level

          If continued : Type :r to resume execution, or :q to quit to top
          level

          Broken at SYSTEM:TERMINAL-INTERRUPT

          Type :H for Help

          Maxima\<gtr\> \<gtr\>:q
        </code>

        <\with|paragraph mode|left>
          <\with|paragraph mode|left>
            A l'invite de Maxima, il faut donc taper :q ( ou :t ) pour
            arrêter le calcul en cours et retourner au prompt de Maxima. Si
            on entre :r, le calcul continuera. L'appui sur les touches CRTL Y
            n'aura aucun effet à part celui d'être indiqué à l'écran. Enfin,
            CRTL Z aura le même effet que la commande quit(); On note CTRL C
            l'appui simultané sur les touches CONTROLE et C du clavier.
          </with>
        </with>
      </with>
    </with>

    <item>Pour arrêter un calcul sans quitter Maxima, tapez CTRL C. Il est
    important de connaître ce que l'on doit faire dans ce cas, qui peut se
    produire si vous lancez un calcul qui dure trop longtemps. Rappelez-vous
    de taper :q à l'invite MAXIMA\<gtr\>\<gtr\> qui apparaîtra, afin de
    revenir à l'écran de saisie des commandes de Maxima.\ 

    <item>Afin de signaler à Maxima la fin d'une entrée de commande, il faut
    mettre à la fin de la saisie un point-virgule, puis appuyer sur la touche
    ENTREE. Remarquez que le seul appui sur la touche ENTREE n'est pas
    suffisant pour faire exécuter une commande par Maxima.

    <item>Une autre façon de signaler la fin d'une commande est d'utiliser le
    symbole dollar, qui supprimera l'affichage du résultat du calcul. Ceci
    est utile si vous évaluez un résultat intermédiaire très long, et que
    vous ne voulez pas perdre de temps à afficher ce résultat à l'écran.

    <item>Si vous voulez répéter une commande antérieure, par exemple celle
    désignée par l'invite (C5), vous pouvez le faire sans retaper la commande
    en faisant précéder l'étiquette par deux simples quottes ( '' ), ce qui
    donnera ''C5. Notez que si vous évaluez juste C5, cela ne correspondra
    pas à l'action recherchée.

    <item>Si vous voulez vous référez au résultat du calcul précédent fait
    par Maxima, vous pouvez soit utiliser son étiquette D, soit utiliser le
    symbole pourcentage ( % ).

    <item>Les constantes <with|mode|math|e> ( exponentielle de 1 ),
    <with|mode|math|i> ( le nombre complexe tel que
    <with|mode|math|i<rsup|2>=-1> ) et <with|mode|math|\<pi\>> sont désignées
    par respectivement %E ( ou %e ), %I ( ou %i ) et %PI ( ou %pi ).
    Remarquez que le % employé ici n'a aucun rapport avec le % désignant le
    résultat précédemment calculé par Maxima.

    <item>Afin d'affecter une valeur à une variable, Maxima utilise le signe
    deux-points ( : ), et non pas le signe égal. Le signe égal sert à écrire
    une équation.

    <section|Arithmétique>\ 

    Les opérations fondamentales sont :

    <\expand|itemize-dot>
      <item>l'addition notée +

      <item>la soustraction notée -

      <item>la multiplication des réels notée *

      <item>la division notée /

      <item>l'élévation à la puissance notée ^ ou **

      <item>la multiplication matricielle notée .

      <item>la fonction racine carrée notée sqrt
    </expand>
  </expand>

  Les sorties de Maxima se font en valeur exacte. Par exemple :

  <\session|maxima|default>
    <\input|maxima] >
      1/100+1/101;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D2) <with|color|black|>><frac|201|10100>>
      </with>

      \;
    </output>
  </session>

  Si on emploie des nombres irrationnels, alors ceux-ci sont conservés sous
  forme symbolique :

  <\session|maxima|default>
    <\input|maxima] >
      (1+sqrt(2))^5;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D3) <with|color|black|>><left|(><sqrt|2>+1<right\
        |)><rsup|5>>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C4) <with|color|black|>
    </with>>
      expand(%);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D4) <with|color|black|>>29*<sqrt|2>+41>
      </with>

      \;
    </output>
  </session>

  Toutefois, il est souvent utile d'obtenir une valeur approchée d'un
  résultat. Cette opération s'effectue en faisant suivre l'expression
  demandée de la commande ,<with|font|pandora|numer> :

  <\session|maxima|default>
    <\input|maxima] >
      %,numer;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D5) <with|color|black|>>82.01219330881976>
      </with>

      \;
    </output>
  </session>

  Notez que le % se réfère ici au résultat du calcul précédent. Par défaut,
  la commande <with|font|pandora|numer> donne 16 chiffres significatifs, le
  dernier pouvant être erroné. Toutefois, Maxima peut calculer avec une
  précision arbitraire aussi importante que l'on veut grâce à la fonction
  <with|font|pandora|bfloat> :

  <\session|maxima|default>
    <\input|maxima] >
      bfloat(D3);
    </input>

    <\output>
      8.201219330881976B1

      \;
    </output>
  </session>

  Le nombre de décimales est contrôlé par la variable Maxima
  <with|font|pandora|FPPREC>, qui a par défaut la valeur 16 :

  <\session|maxima|default>
    <\input|maxima] >
      fpprec;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D7) <with|color|black|>>16>
      </with>

      \;
    </output>
  </session>

  Assignons à cette variable la valeur 100 :

  <\session|maxima|default>
    <\input|maxima] >
      fpprec:100;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D8) <with|color|black|>>100>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C9) <with|color|black|>
    </with>>
      bfloat(D3);
    </input>

    <\output>
      8.2012193308819756415248973002081244278520484385931494122123712401731

      \ 2418754011041266612384955016056B1

      \;
    </output>
  </session>

  Maxima peut calculer les valeurs exactes de très grand nombres :

  <\session|maxima|default>
    <\input|maxima] >
      100!;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D12) <with|color|black|>>93326215443944152681699\
        238856266700490715968264381621468592963895217599993229915608941463976\
        156518286253697920827223758251185210916864000000000000000000000000>
      </with>

      \;
    </output>
  </session>

  <section|Algèbre>

  L'importance de Maxima comme logiciel de calcul formel appairait clairement
  quand nous voyons avec quelle facilité le logiciel va effectuer des calculs
  algébriques. Voici un exemple de développement d'un polynôme :

  <\session|maxima|default>
    <\output>
      \;
    </output>

    <\input|<\with|color|red>
      (C1) <with|color|black|>
    </with>>
      (x+3*y+x^2*y)^3;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D1) <with|color|black|>><left|(>x<rsup|2>*y+3*y+\
        x<right|)><rsup|3>>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C2) <with|color|black|>
    </with>>
      expand(%);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D2) <with|color|black|>>x<rsup|6>*y<rsup|3>+9*x<\
        rsup|4>*y<rsup|3>+27*x<rsup|2>*y<rsup|3>+27*y<rsup|3>+3*x<rsup|5>*y<r\
        sup|2>+18*x<rsup|3>*y<rsup|2>+27*x*y<rsup|2>+3*x<rsup|4>*y+9*x<rsup|2\
        >*y+x<rsup|3>>
      </with>

      \;
    </output>
  </session>

  \;

  Supposons maintenant que nous voulons remplacer <with|mode|math|x> par la
  valeur <with|mode|math|<frac|5|z>> dans l'expression précédente :

  <\session|maxima|default>
    <\input|maxima] >
      d2,x=5/z;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D4) <with|color|black|>><frac|135*y<rsup|2>|z>+<\
        frac|675*y<rsup|3>|z<rsup|2>>+<frac|225*y|z<rsup|2>>+<frac|2250*y<rsu\
        p|2>|z<rsup|3>>+<frac|125|z<rsup|3>>+<frac|5625*y<rsup|3>|z<rsup|4>>+\
        <frac|1875*y|z<rsup|4>>+<frac|9375*y<rsup|2>|z<rsup|5>>+<frac|15625*y\
        <rsup|3>|z<rsup|6>>+27*y<rsup|3>>
      </with>

      \;
    </output>
  </session>

  La fonction RATSIMP de Maxima réduit l'expression au même dénominateur :

  <\session|maxima|default>
    <\input|maxima] >
      ratsimp(%);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D5) <with|color|black|>><frac|27*y<rsup|3>*z<rsu\
        p|6>+135*y<rsup|2>*z<rsup|5>+<left|(>675*y<rsup|3>+225*y<right|)>*z<r\
        sup|4>+<left|(>2250*y<rsup|2>+125<right|)>*z<rsup|3>+<left|(>5625*y<r\
        sup|3>+1875*y<right|)>*z<rsup|2>+9375*y<rsup|2>*z+15625*y<rsup|3>|z<r\
        sup|6>>>
      </with>

      \;
    </output>
  </session>

  Les expressions peuvent être factorisées :

  <\session|maxima|default>
    <\input|maxima] >
      factor(%);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D6) <with|color|black|>><frac|<left|(>3*y*z<rsup\
        |2>+5*z+25*y<right|)><rsup|3>|z<rsup|6>>>
      </with>

      \;
    </output>
  </session>

  Maxima peut trouver les valeurs exactes des solutions de systèmes
  d'équations algébriques, même dans des cas non linéaires. Dans l'exemple
  suivant, on résout trois équations dont les inconnues sont
  <with|mode|math|a>, <with|mode|math|b> et <with|mode|math|c> :

  <\session|maxima|default>
    <\input|maxima] >
      a+b*c=1;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D7) <with|color|black|>>b*c+a=1>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C8) <with|color|black|>
    </with>>
      b-a*c=0;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D8) <with|color|black|>>b-a*c=0>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C9) <with|color|black|>
    </with>>
      a+b=5;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D9) <with|color|black|>>b+a=5>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C10) <with|color|black|>
    </with>>
      solve([d7,d8,d9],[a,b,c]);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D10) <with|color|black|>><left|[><left|[>a=<frac\
        |25*<sqrt|79>*i+25|6*<sqrt|79>*i-34>,b=<frac|5*<sqrt|79>*i+5|<sqrt|79\
        >*i+11>,c=<frac|<sqrt|79>*i+1|10><right|]>,<left|[>a=<frac|25*<sqrt|7\
        9>*i-25|6*<sqrt|79>*i+34>,b=<frac|5*<sqrt|79>*i-5|<sqrt|79>*i-11>,c=-\
        <frac|<sqrt|79>*i-1|10><right|]><right|]>>
      </with>

      \;
    </output>
  </session>

  Remarquez que la sortie consiste en une " liste ", c'est à dire en une
  expression comprise entre deux crochets [ ... ], qui contient elle-même
  deux listes. Chacune de ces dernières contient une solution au système
  d'équations.

  Les formules trigonométriques se manipulent aisément avec Maxima. La
  fonction TRIGEXPAND utilise la formule de la somme afin de simplifier au
  maximum l'argument de chacune des fonctions trigonométriques utilisées :

  <\session|maxima|default>
    \;

    <\input|<\with|color|red>
      (C1) <with|color|black|>
    </with>>
      sin(u+v)*cos(u)^3;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D1) <with|color|black|>>cos <rsup|3>u*sin
        <left|(>v+u<right|)>>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C2) <with|color|black|>
    </with>>
      trigexpand(%);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D2) <with|color|black|>>cos
        <rsup|3>u*<left|(>cos u*sin v+sin u*cos v<right|)>>
      </with>

      \;
    </output>
  </session>

  Inversement, la fonction TRIGREDUCE transforme une expression
  trigonométrique en une somme de termes dont chacun ne comporte qu'une seule
  fois la fonction sinus ou la fonction cosinus :

  <\session|maxima|default>
    <\input|maxima] >
      trigreduce(d1);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D3) <with|color|black|>><frac|sin
        <left|(>v+4*u<right|)>+sin <left|(>v-2*u<right|)>|8>+<frac|3*sin
        <left|(>v+2*u<right|)>+3*sin v|8>>
      </with>

      \;
    </output>
  </session>

  Les fonctions REALPART et IMAGPART renvoient respectivement la partie
  réelle et la partie imaginaire d'un nombre complexe :

  <\session|maxima|default>
    <\input|maxima] >
      w:3+k*%i;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D4) <with|color|black|>>i*k+3>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C5) <with|color|black|>
    </with>>
      w^2*%e^w;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D5) <with|color|black|>><left|(>i*k+3<right|)><r\
        sup|2>*e<rsup|i*k+3>>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C6) <with|color|black|>
    </with>>
      realpart(%);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D6) <with|color|black|>>e<rsup|3>*<left|(>9-k<rs\
        up|2><right|)>*cos k-6*e<rsup|3>*k*sin k>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C7) <with|color|black|>
    </with>>
      imagpart(D5);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D7) <with|color|black|>>e<rsup|3>*<left|(>9-k<rs\
        up|2><right|)>*sin k+6*e<rsup|3>*k*cos k>
      </with>
    </output>
  </session>

  <section|Calcul différentiel>

  Maxima calcule dérivées et intégrales, effectue des développements en série
  de Taylor, trouve les limites, et sait résoudre en valeur exacte les
  équations différentielles ordinaires. Nous commençons par définir la
  fonction <with|mode|math|f> de la variable numérique <with|mode|math|x> par
  :

  <\session|maxima|default>
    <\input|maxima] >
      f:x^3*%e^(k*x)*sin(a*x);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D9) <with|color|black|>>x<rsup|3>*e<rsup|k*x>*si\
        n <left|(>a*x<right|)>>
      </with>

      \;
    </output>
  </session>

  On calcule l'expression de la dérivée de <with|mode|math|f> par rapport à
  <with|mode|math|x> :

  <\session|maxima|default>
    <\input|maxima] >
      diff(f,x);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D10) <with|color|black|>>k*x<rsup|3>*e<rsup|k*x>\
        *sin <left|(>a*x<right|)>+3*x<rsup|2>*e<rsup|k*x>*sin
        <left|(>a*x<right|)>+a*x<rsup|3>*e<rsup|k*x>*cos
        <left|(>a*x<right|)>>
      </with>

      \;
    </output>
  </session>

  Maintenant, on calcule une primitive de <with|mode|math|f> par rapport à
  <with|mode|math|x> :

  <\session|maxima|default>
    <\input|maxima] >
      integrate(f,x);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|font size|0.71|<with|mode|text|font
        family|tt|color|red|(D11) <with|color|black|>><frac|<left|(><left|(>k\
        <rsup|7>+3*a<rsup|2>*k<rsup|5>+3*a<rsup|4>*k<rsup|3>+a<rsup|6>*k<righ\
        t|)>*x<rsup|3>+<left|(>-3*k<rsup|6>-3*a<rsup|2>*k<rsup|4>+3*a<rsup|4>\
        *k<rsup|2>+3*a<rsup|6><right|)>*x<rsup|2>+<left|(>6*k<rsup|5>-12*a<rs\
        up|2>*k<rsup|3>-18*a<rsup|4>*k<right|)>*x-6*k<rsup|4>+36*a<rsup|2>*k<\
        rsup|2>-6*a<rsup|4><right|)>*e<rsup|k*x>*sin
        <left|(>a*x<right|)>+<left|(><left|(>-a*k<rsup|6>-3*a<rsup|3>*k<rsup|\
        4>-3*a<rsup|5>*k<rsup|2>-a<rsup|7><right|)>*x<rsup|3>+<left|(>6*a*k<r\
        sup|5>+12*a<rsup|3>*k<rsup|3>+6*a<rsup|5>*k<right|)>*x<rsup|2>+<left|\
        (>-18*a*k<rsup|4>-12*a<rsup|3>*k<rsup|2>+6*a<rsup|5><right|)>*x+24*a*\
        k<rsup|3>-24*a<rsup|3>*k<right|)>*e<rsup|k*x>*cos
        <left|(>a*x<right|)>|k<rsup|8>+4*a<rsup|2>*k<rsup|6>+6*a<rsup|4>*k<rs\
        up|4>+4*a<rsup|6>*k<rsup|2>+a<rsup|8>>>>
      </with>

      \;
    </output>
  </session>

  Un léger changement de syntaxe fournit l'intégrale définie :

  <\session|maxima|default>
    <\input|maxima] >
      integrate(1/x^2,x,1,inf);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D12) <with|color|black|>>1>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C13) <with|color|black|>
    </with>>
      integrate(1/x,x,0,inf);
    </input>

    <\output>
      Integral is divergent

      \ -- an error. \ Quitting. \ To debug this try DEBUGMODE(TRUE);)

      \;
    </output>
  </session>

  Ensuite, nous définissons la fonction <with|mode|math|g> à l'aide de la
  fonction <with|mode|math|f> et du sinus hyperbolique, puis nous trouvons le
  développement en série de Taylor de <with|mode|math|g> à l'ordre 3 au
  voisinage de <with|mode|math|x=0>.

  <\session|maxima|default>
    <\input|maxima] >
      g:f/sinh(k*x)^4;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D14) <with|color|black|>><frac|x<rsup|3>*e<rsup|\
        k*x>*sin <left|(>a*x<right|)>|sinh <rsup|4><left|(>k*x<right|)>>>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C15) <with|color|black|>
    </with>>
      taylor(g,x,0,3);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D15) <with|color|black|>><frac|a|k<rsup|4>>+<fra\
        c|a*x|k<rsup|3>>-<frac|<left|(>a*k<rsup|2>+a<rsup|3><right|)>*x<rsup|\
        2>|6*k<rsup|4>>-<frac|<left|(>3*a*k<rsup|2>+a<rsup|3><right|)>*x<rsup\
        |3>|6*k<rsup|3>>+\<cdots\>>
      </with>

      \;
    </output>
  </session>

  La limite de <with|mode|math|g> quand <with|mode|math|x> tend vers
  <with|mode|math|0> se calcule par l'instruction suivante :

  <\session|maxima|default>
    <\input|maxima] >
      limit(g,x,0);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D16) <with|color|black|>><frac|a|k<rsup|4>>>
      </with>

      \;
    </output>
  </session>

  Maxima peut aussi représenter des dérivées sous une forme non évaluée. On
  remarquera le signe quotte (') devant l'expression :

  <\session|maxima|default>
    <\input|maxima] >
      'diff(y,x);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D17) <with|color|black|>><frac|d|d*x>*y>
      </with>

      \;
    </output>
  </session>

  L'opérateur quotte (') dans l'expression précédente signifie " ne pas
  évaluer ". Sans ce symbole, Maxima aurait retourné 0 :

  <\session|maxima|default>
    <\input|maxima] >
      diff(y,x);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D18) <with|color|black|>>0>
      </with>

      \;
    </output>
  </session>

  En utilisant ce symbole quotte ('), on peut écrire des équations
  différentielles :

  <\session|maxima|default>
    <\input|maxima] >
      'diff(y,x,2)+'diff(y,x)+y;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D19) <with|color|black|>><frac|d<rsup|2>|d*x<rsu\
        p|2>>*y+<frac|d|d*x>*y+y>
      </with>

      \;
    </output>
  </session>

  La fonction ODE2 de Maxima peut résoudre des équations différentielles du
  premier et second ordre :

  <\session|maxima|default>
    <\input|maxima] >
      ode2(D19,y,x);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D20) <with|color|black|>>y=e<rsup|-<frac|x|2>>*<\
        left|(><with|math font family|rm|%K1>*sin
        <left|(><frac|<sqrt|3>*x|2><right|)>+<with|math font
        family|rm|%K2>*cos <left|(><frac|<sqrt|3>*x|2><right|)><right|)>>
      </with>

      \;
    </output>
  </session>

  %K1 et %K2 désignent des constantes réelles.

  <section|Calcul matriciel>

  Maxima peut calculer le déterminant, l'inverse, les valeurs propres et les
  vecteurs propres d'une matrice qui comporte des éléments symboliques (
  c'est à dire des expressions avec des variables algébriques ). On commence
  par entrer une matrice <with|mode|math|m> élément par élément :

  <\session|maxima|default>
    <\input|maxima] >
      m:entermatrix(3,3);
    </input>

    <\output>
      Is the matrix \ 1. Diagonal \ 2. Symmetric \ 3. Antisymmetric \ 4.
      General

      \;
    </output>

    <\input|<\with|color|red>
      Answer 1, 2, 3 or 4 : <with|color|black|>
    </with>>
      4;
    </input>

    <\input|<\with|color|red>
      Row 1 Column 1: <with|color|black|>
    </with>>
      0;
    </input>

    <\input|<\with|color|red>
      Row 1 Column 2: <with|color|black|>
    </with>>
      1;
    </input>

    <\input|<\with|color|red>
      Row 1 Column 3: <with|color|black|>
    </with>>
      a;
    </input>

    <\input|<\with|color|red>
      Row 2 Column 1: <with|color|black|>
    </with>>
      1;
    </input>

    <\input|<\with|color|red>
      Row 2 Column 2: <with|color|black|>
    </with>>
      0;
    </input>

    <\input|<\with|color|red>
      Row 2 Column 3: <with|color|black|>
    </with>>
      1;
    </input>

    <\input|<\with|color|red>
      Row 3 Column 1: <with|color|black|>
    </with>>
      1;
    </input>

    <\input|<\with|color|red>
      Row 3 Column 2: <with|color|black|>
    </with>>
      1;
    </input>

    <\input|<\with|color|red>
      Row 3 Column 3: <with|color|black|>
    </with>>
      0;
    </input>

    <\output>
      Matrix entered.

      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D21) <with|color|black|>><left|(><expand|tabular\
        *|<tformat|<table|<row|<cell|0>|<cell|1>|<cell|a>>|<row|<cell|1>|<cel\
        l|0>|<cell|1>>|<row|<cell|1>|<cell|1>|<cell|0>>>>><right|)>>
      </with>

      \;
    </output>
  </session>

  On calcule ensuite sa transposée, son déterminant et son inverse :

  <\session|maxima|default>
    <\input|maxima] >
      transpose(m);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D22) <with|color|black|>><left|(><expand|tabular\
        *|<tformat|<table|<row|<cell|0>|<cell|1>|<cell|1>>|<row|<cell|1>|<cel\
        l|0>|<cell|1>>|<row|<cell|a>|<cell|1>|<cell|0>>>>><right|)>>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C23) <with|color|black|>
    </with>>
      determinant(m);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D23) <with|color|black|>>a+1>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C24) <with|color|black|>
    </with>>
      invert(m),detout;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D24) <with|color|black|>><frac|<left|(><expand|t\
        abular*|<tformat|<table|<row|<cell|-1>|<cell|a>|<cell|1>>|<row|<cell|\
        1>|<cell|-a>|<cell|a>>|<row|<cell|1>|<cell|1>|<cell|-1>>>>><right|)>|\
        a+1>>
      </with>

      \;
    </output>
  </session>

  Dans l'entrée C24, l'option detout impose la factorisation par le
  déterminant, ce dernier restant à l'extérieur de la matrice. Comme
  vérification, on peut multiplier <with|mode|math|m> par son inverse (
  remarquer l'usage du point (.) pour désigner le produit matriciel ) :

  <\session|maxima|default>
    <\input|maxima] >
      m.d24;
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D25) <with|color|black|>><left|(><expand|tabular\
        *|<tformat|<table|<row|<cell|0>|<cell|1>|<cell|a>>|<row|<cell|1>|<cel\
        l|0>|<cell|1>>|<row|<cell|1>|<cell|1>|<cell|0>>>>><right|)>\<cdot\><f\
        rac|<left|(><expand|tabular*|<tformat|<table|<row|<cell|-1>|<cell|a>|\
        <cell|1>>|<row|<cell|1>|<cell|-a>|<cell|a>>|<row|<cell|1>|<cell|1>|<c\
        ell|-1>>>>><right|)>|a+1>>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C26) <with|color|black|>
    </with>>
      expand(%);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D26) <with|color|black|>><left|(><expand|tabular\
        *|<tformat|<table|<row|<cell|<frac|a|a+1>+<frac|1|a+1>>|<cell|0>|<cel\
        l|0>>|<row|<cell|0>|<cell|<frac|a|a+1>+<frac|1|a+1>>|<cell|0>>|<row|<\
        cell|0>|<cell|0>|<cell|<frac|a|a+1>+<frac|1|a+1>>>>>><right|)>>
      </with>

      \;
    </output>

    <\input|<\with|color|red>
      (C27) <with|color|black|>
    </with>>
      factor(%);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D27) <with|color|black|>><left|(><expand|tabular\
        *|<tformat|<table|<row|<cell|1>|<cell|0>|<cell|0>>|<row|<cell|0>|<cel\
        l|1>|<cell|0>>|<row|<cell|0>|<cell|0>|<cell|1>>>>><right|)>>
      </with>

      \;
    </output>
  </session>

  Pour trouver valeurs et vecteurs propres, on utilise la commande
  EIGENVECTORS :

  <\session|maxima|default>
    <\input|maxima] >
      eigenvectors(m);
    </input>

    <\output>
      Warning - you are redefining the MACSYMA function EIGENVALUES

      Warning - you are redefining the MACSYMA function EIGENVECTORS

      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D28) <with|color|black|>><left|[><left|[><left|[\
        >-<frac|<sqrt|4*a+5>-1|2>,<frac|<sqrt|4*a+5>+1|2>,-1<right|]>,<left|[\
        >1,1,1<right|]><right|]>,<left|[>1,-<frac|<sqrt|4*a+5>-1|2*a+2>,-<fra\
        c|<sqrt|4*a+5>-1|2*a+2><right|]>,<left|[>1,<frac|<sqrt|4*a+5>+1|2*a+2\
        >,<frac|<sqrt|4*a+5>+1|2*a+2><right|]>,<left|[>1,-1,0<right|]><right|\
        ]>>
      </with>

      \;
    </output>
  </session>

  Dans l'expression D28, le premier crochet à l'intérieur du triple crochet
  donne les trois valeurs propres, le suivant leur ordre de multiplicité
  respectifs, et les crochets suivants fournissent les coordonnées des
  vecteurs propres associés aux valeurs propres. Afin d'extraire un vecteur
  propre de l'expression précédente, on utilise la commande PART :

  <\session|maxima|default>
    <\input|maxima] >
      part(D28,2);
    </input>

    <\output>
      <\with|mode|math>
        <with|formula style|true|<with|mode|text|font
        family|tt|color|red|(D29) <with|color|black|>><left|[>1,-<frac|<sqrt|\
        4*a+5>-1|2*a+2>,-<frac|<sqrt|4*a+5>-1|2*a+2><right|]>>
      </with>
    </output>
  </session>

  <section|Programmer avec Maxima>

  Jusqu'à présent, nous avons utilisé Maxima en mode interactif, comme une
  super calculatrice. Toutefois, pour des calculs qui nécessitent une
  séquence de commandes répétitive, il est préférable d'exécuter un
  programme. Nous présentons maintenant un exemple de court programme
  \ permettant le calcul des points critiques d'une fonction
  <with|mode|math|f> de deux variables <with|mode|math|x> et
  <with|mode|math|y>. Le programme demande à l'utilisateur d'entrer une
  fonction <with|mode|math|f>, puis il calcule les dérivées partielles
  <with|mode|math|<frac|\<partial\>f|\<partial\>x> et
  ><with|mode|math|<frac|\<partial\>f|\<partial\>y>>, et enfin il fait appel
  à la commande SOLVE de Maxima pour obtenir les solutions du système
  d'équations :

  <\expand|equation*>
    <with|mode|text|<with|mode|math|<frac|\<partial\>f|\<partial\>x>=0
    \ \ \ \ et \ \ \ ><with|mode|math|<frac|\<partial\>f|\<partial\>y>=0>>
  </expand>

  Le programme est écrit avec un éditeur de textes quelconque, puis est
  chargé dans Maxima avec la commande BATCH. Voici le listing du programme :

  <\code>
    /*-----------------------------------------------------------------------\
    ---

    Ceci est le programme critpts.max comme vous le voyez,

    les commentaires avec Maxima sont analogues à ceux en langage C

    Auteur : Nelson Luis Dias

    Créé le 07/07/2000

    -------------------------------------------------------------------------\
    --*

    critpts():=(

    print("Programme pour déterminer les points critiques "),

    /* ----------------------------------------------------------------------\
    ---

    On entre une fonction

    -------------------------------------------------------------------------\
    --*

    f:read("Entrez f(x,y)"),

    /*-----------------------------------------------------------------------\
    ---

    On renvoie la réponse pour vérification

    -------------------------------------------------------------------------\
    --*

    print("f = ",f),

    /*-----------------------------------------------------------------------\
    ---

    On construit une liste avec les dérivées partielles :

    -------------------------------------------------------------------------\
    --*

    eqs:[diff(f,x),diff(f,y)],

    /*-----------------------------------------------------------------------\
    ---

    On construit la liste des inconnues

    -------------------------------------------------------------------------\
    --*

    unk:[x,y],

    /*-----------------------------------------------------------------------\
    ---

    On résout le système\ 

    -------------------------------------------------------------------------\
    --*

    solve(eqs,unk)

    )<with|mode|math|>

    $
  </code>

  Le programme ( qui est en l'état actuel une fonction sans argument )
  s'appelle critpts. Chaque ligne est une commande ( qui doit être valide )
  Maxima qui pourrait être exécutée en mode interactif, et qui est séparée de
  la commande suivante par une virgule. Les dérivées partielles sont stockées
  dans une liste qui s'appelle eqs, et les inconnues dans une liste qui
  s'appelle unk. Voici un exemple d'exécution du programme :

  <\session|maxima|default>
    \;

    <\input|<\with|color|red>
      (C1) <with|color|black|>
    </with>>
      batch("/home/michel/temp/critpts.max");
    </input>

    batching #p/home/michel/temp/critpts.max\ 

    (C2) critpts() := (PRINT("Programme recherchant les points critiques "),

    f : READ("Entrez f(x,y)"), PRINT(" f = ", f), eqs : [DIFF(f, x), DIFF(f,
    y)],

    unk : [x, y], SOLVE(eqs, unk))
  </session>

  (C3) critpts();

  Programme recherchant les points critiques\ 

  Entrez f(x,y)\ 

  %E^(x^3+y^2)*(x+y);\ 

  <with|mode|math|f=(y+x)e<rsup|y<rsup|2>+x<rsup|3>>>

  (D3) [[x = 0.4588955685487 %I + 0.35897908710869,

  y = 0.49420173682751 %I - 0.12257873677837],

  [x = 0.35897908710869 - 0.4588955685487 %I,

  y = - 0.49420173682751 %I - 0.12257873677837],

  [x = 0.41875423272348 %I - 0.69231242044203,

  y = 0.86972626928141 %I + 0.4559120701117]]

  y = 0.4559120701117 - 0.86972626928141 %I],

  [x = - 0.41875423272348 %I - 0.69231242044203,

  y = 0.86972626928141 %I + 0.4559120701117]]

  <section|Une liste partielle des fonctions Maxima>

  Vous pouvez consulter le manuel Maxima dans le sous-répertoire maxima-/info
  au format texinfo ou html. A l'intérieur de Maxima, vous pouvez utiliser la
  commande DESCRIBE(nom de la fonction ).

  <\expand|itemize-dot>
    <item>ALLROOTS(A)\ 

    Trouve toutes les solutions en valeur approchée ( avec 16 chiffres
    significatifs par défaut ), éventuellement dans le corps des nombres
    complexes, d'une équation polynomiale A, et en donne une liste.

    <item>APPEND(A,B)

    Réunit la liste A et la liste B, et donc renvoie une liste unique.

    <item>BATCH(A)

    Charge et lance un programme BATCH du nom de A

    <item>COEFF(A,B,C)

    Renvoie le coefficient de B puissance C dans l'expression A

    <item>CONCAT(A,B)

    Crée le symbole AB

    <item>CONS(A,B)

    Ajoute A à la liste B en première position

    <item>DEMOIVRE(A)

    Transforme toutes les exponentielles complexes sous forme trigonométrique

    <item>DENOM(A)

    Renvoie le dénominateur de A

    <item>DEPENDS(A,B)

    Cette commande indique que A est une fonction de B. Cette dernière est
    utile pour écrire des dérivées de manière générale, comme par exemple
    dans les équations différentielles.

    <item>DESOLVE(A,B)

    Essaie de résoudre un système linéaire A d'équations différentielles
    d'inconnues B en utilisant la transformée de Laplace

    <item>DETERMINANT(A)

    Renvoie le déterminant de la matrice carrée A

    <item>DIFF(A,B1,C1,B2,C2,...,Bn,Cn)

    Renvoie les dérivées partielles de A par rapport aux variables B1 à la
    puissance C1, B2 à la puissance C2, etc..; Un raccourci pour DIFF(A,B,1)
    est DIFF(A,B). 'DIFF(A,B) représente la dérivée sous forme non évaluée,
    ce qui est utile pour les équations différentielles.

    <item>EIGENVALUES(A)

    Renvoie deux listes, la première étant les valeurs propres d'une matrice
    carrée A, et la seconde leur ordre respectif de multiplicité.

    <item>EIGENVECTORS(A)

    Fait la même chose que la commande précédente, mais rajoute la liste des
    vecteurs propres associés

    <item>ENTERMATRIX(A,B)

    Demande à l'utilisateur d'entrer une matrice n sur m, élément par élément

    <item>EV(A,B1,B2,...,Bn)

    Évalue A en tenant compte des conditions B1, B2, ... Bn. En particulier,
    les Bi peuvent être des équations, des listes d'équations ( comme ce que
    retourne la commande SOLVE ), ou bien des assignations, c'est à dire que
    dans ce cas la commande EV remplace les Bi par leurs valeurs dans A. Les
    Bi peuvent être des mots comme NUMER ( ce qui dans ce cas renvoie une
    valeur numérique pour A ), DETOUT ( ce qui dans ce cas entraîne que tout
    calcul de matrice inverse se fera en gardant le déterminant en facteur,
    c'est à dire à l'extérieur de la matrice ), ou DIFF ( et dans ce cas tous
    les calculs de dérivation sont effectués, c'est à dire que 'DIFF est
    remplacé par DIFF). Pour abréger une commande interactive, c'est à dire
    qui n'est pas incluse dans la définition d'une fonction, la commande EV
    peut être omise, ce qui raccourcit la commande sous la forme :
    A,B1,B2,...,Bn

    <item>EXPAND(A)

    Effectue le développement de A. En particulier, les multiplications sont
    distribuées par rapport aux additions.

    <item>EXPONENTIALIZE(A)

    Transforme toutes les fonctions trigonométriques contenues dans A en
    exponentielles complexes.

    <item>FACTOR(A)

    Factorise l'expression A

    <item>FREEOF(A,B)

    Renvoie TRUE si l'expression B ne comporte pas la variable A

    <item>GRIND(A)

    Ecrit une variable ou une fonction A sous une forme compacte. Si cette
    commande est utilisée avec WRITEFILE et un éditeur de textes, cela permet
    de produire des fichiers BATCH incluant des expressions générées par
    Maxima.

    <item>IDENT(A)

    Renvoie la matrice identité d'ordre A

    <item>IMAGPART(A)

    Renvoie la partie imaginaire de A

    <item>INTEGRATE(A,B)

    Essaie de déterminer une primitive de A par rapport à B

    <item>INTEGRATE(A,B,C,D)

    Essaie de calculer l'intégrale de A par rapport à B entre les bornes C et
    D. Les bornes de l'intégrale peuvent être INF ( plus l'infini ) ou MINF (
    moins l'infini ).

    <item>INVERT(A)

    Calcule la matrice inverse de la matrice carrée A

    <item>KILL(A)

    Élimine la variable A de toutes les définitions et propriétés de
    l'environnement actuel de Maxima

    <item>LIMIT(A,B,C)

    Donne la limite de l'expression A quand B tend vers C. Cette dernière
    variable peut prendre comme valeur INF ( plus l'infini ) ou MINF (moins
    l'infini ), comme pour l'intégrale définie.

    <item>LHS(A)

    Donne le membre de gauche d'une équation A

    <item>LOADFILE(A)

    Charge un fichier du nom de A situé dans le répertoire courant. Le
    fichier doit être dans un format adapté, c'est à dire avoir été
    auparavant créé par la commande SAVE

    <item>MAKELIST(A,B,C,D)

    Crée une liste d'éléments A ( chacun d'eux dépendant probablement de B )
    pour B variant de C à D

    <item>MAP(A,B)

    Applique la fonction A à la sous-expression B

    <item>MATRIX(A1,A2,...An)

    Crée la matrice dont les lignes sont les Ai, chacun des Ai étant une
    liste de m éléments [B1,B2,...Bm]

    <item>NUM(A)

    Renvoie le numérateur de A

    <item>ODE2(A,B,C)

    Essaie de résoudre l'équation différentielle du premier ou du second
    ordre A d'inconnue la fonction B dont la variable est C

    <item>PART(A,B1,B2,...Bn)

    Prend la B1 ième partie de A, puis la B2 ième partie de A, et ainsi de
    suite

    <item>PLAYBACK(A)

    Affiche les dernières A ( entiers ) sorties produites par Maxima. Si A
    n'est pas fourni, alors toutes les lignes depuis le début de la session
    sont affichées\ 

    <item>RATSIMP(A)

    Simplifie A et renvoie le quotient de deux polynômes

    <item>REALPART(A)

    Renvoie la partie réelle de A

    <item>RHS(A)

    Donne le membre de droite d'une équation A

    <item>SAVE(A,B1,B2,...Bn)

    Crée un fichier dont le nom est A dans le sous-répertoire par défaut,
    contenant les variables, les fonctions ou les tableaux Bi. Le format de
    ce fichier permet son chargement ultérieur dans Maxima en utilisant la
    commande LOADFILE. Toute la session, incluant les étiquettes, peut être
    sauvegardée en choisissant B1 égal à ALL.\ 

    <item>SOLVE(A,B)

    Essaie de résoudre l'équation algébrique A d'inconnue B. Une liste des
    solutions est renvoyée. Par simplification, si A est une équation de la
    forme C=0, alors il est possible de n'écrire que C seulement.

    <item>STRING(A)

    Convertit A en notation linéaire Maxima, analogue à celle utilisée en
    Fortran, comme si l'expression avait été entrée directement, et mets A
    dans un buffer pour une édition possible. L'expression ainsi obtenue ne
    doit pas être employée pour des calculs ultérieurs.

    <item>STRINGOUT(A,B1,B2,..,Bn)

    Crée un fichier dont le nom est A dans le sous-répertoire courant,
    contenant les variables B1, B2,..Bn. Ce fichier est au format texte et on
    ne peut pas l'ouvrir avec Maxima. Cependant, les expressions sauvegardées
    ainsi peuvent être réutilisées dans un programme en Fortran, en Basic ou
    en C avec quelques modifications.

    <item>SUBST(A,B,C)

    Remplace la valeur A par B dans C

    <item>TAYLOR(A,B,C,D)

    Développe A en série de Taylor par rapport à la variable B au voisinage
    de C, jusqu'à l'ordre D, en incluant le terme
    (B-C)<with|mode|math|<rsup|D>>. Maxima peut aussi effectuer des
    développements en série de Taylor avec plus d'une variable indépendante.
    Consulter le manuel Maxima.

    <item>TRANSPOSE(A)

    Renvoie la transposée de la matrice A

    <item>TRIGEXPAND(A)

    Est une fonction de simplication trigonométrique qui utilise la formule
    de la somme des angles pour simplifier les arguments des fonctions SIN et
    COS rencontrées. Par exemple, TRIGEXPAND(SIN(x+y)) donne
    COS(x)SIN(y)+SIN(x)COS(y).

    <item>TRIGREDUCE(A)

    Est une fonction de simplication trigonométrique qui utilise des égalités
    trigonométriques pour convertir des produits et des puissances de SIN et
    COS en une somme de termes, chacun d'eux ne contenant qu'une seule fois
    la fonction SIN ou COS. Par exemple, TRIGREDUCE(SIN(x)^2) donne
    (1-COS(2x))/2.

    <item>TRIGSIMP(A)

    Est une fonction de simplification trigonométrique qui remplace TAN, SEC,
    etc, par leurs équivalents en SIN et COS. L'égalité
    SIN(<with|mode|math|x>)<with|mode|math|<rsup|2>+COS(x)<rsup|2>=1> est
    aussi utilisée.\ 
  </expand>

  \;
</body>

<\initial>
  <\collection>
    <associate|odd page margin|30mm>
    <associate|paragraph width|150mm>
    <associate|page medium|paper>
    <associate|shrinking factor|4>
    <associate|page right margin|30mm>
    <associate|page top margin|30mm>
    <associate|reduction page right margin|25mm>
    <associate|reduction page bottom margin|15mm>
    <associate|page type|a4>
    <associate|reduction page left margin|25mm>
    <associate|even page margin|30mm>
    <associate|page bottom margin|30mm>
    <associate|reduction page top margin|15mm>
    <associate|language|french>
    <associate|show header and footer|true>
  </collection>
</initial>

<\references>
  <\collection>
    <associate|toc-1|<tuple|1|1>>
    <associate|toc-2|<tuple|2|2>>
    <associate|toc-3|<tuple|3|2>>
    <associate|toc-4|<tuple|4|4>>
    <associate|toc-5|<tuple|5|6>>
    <associate|toc-6|<tuple|6|7>>
    <associate|toc-7|<tuple|7|9>>
    <associate|toc-8|<tuple|8|10>>
    <associate|toc-9|<tuple|8|10>>
  </collection>
</references>

<\auxiliary>
  <\collection>
    <\associate|toc>
      <vspace*|1fn><with|font series|<quote|bold>|math font
      series|<quote|bold>|1<space|2spc>Introduction><value|toc-dots><pageref|\
      toc-1><vspace|0.5fn>

      <vspace*|1fn><with|font series|<quote|bold>|math font
      series|<quote|bold>|2<space|2spc>Les touches et les symboles
      spéciaux><value|toc-dots><pageref|toc-2><vspace|0.5fn>

      <vspace*|1fn><with|font series|<quote|bold>|math font
      series|<quote|bold>|3<space|2spc>Arithmétique><value|toc-dots><pageref|\
      toc-3><vspace|0.5fn>

      <vspace*|1fn><with|font series|<quote|bold>|math font
      series|<quote|bold>|4<space|2spc>Algèbre><value|toc-dots><pageref|toc-4\
      ><vspace|0.5fn>

      <vspace*|1fn><with|font series|<quote|bold>|math font
      series|<quote|bold>|5<space|2spc>Calcul
      différentiel><value|toc-dots><pageref|toc-5><vspace|0.5fn>

      <vspace*|1fn><with|font series|<quote|bold>|math font
      series|<quote|bold>|6<space|2spc>Calcul
      matriciel><value|toc-dots><pageref|toc-6><vspace|0.5fn>

      <vspace*|1fn><with|font series|<quote|bold>|math font
      series|<quote|bold>|7<space|2spc>Programmer avec
      Maxima><value|toc-dots><pageref|toc-7><vspace|0.5fn>

      <vspace*|1fn><with|font series|<quote|bold>|math font
      series|<quote|bold>|8<space|2spc>Une liste partielle des fonctions
      Maxima><value|toc-dots><pageref|toc-8><vspace|0.5fn>
    </associate>
  </collection>
</auxiliary>
