<TeXmacs|1.0.4>

<style|<tuple|generic|axiom>>

<\body>
  <postscript|<tuple|<#[encoded data, 22420 characters]>|gif>|*4/8|*4/8||||>

  CARPENT Quentin

  CONIL Christophe

  \;

  \;

  \;

  <with|font-size|1.41|<\with|par-mode|center>
    <with|font-series|bold|<with|font-size|1.68|AC20>>

    <with|font-size|1.41|<\with|par-mode|center>
      Utilisation de logiciels libres pour la réalisation de TP MT26
    </with>>
  </with>>

  \;

  <\with|par-mode|center>
    <block*|<tformat|<table|<row|<cell|<postscript|mt26/shot.jpg|*5/8|*5/8||||>>>>>>
  </with>

  \;

  \;

  <with|font-series|bold|<with|font-size|1.41|<\with|par-mode|center>
    Étude de la faisabilité
  </with>>>

  \;

  \;

  \;

  \;

  <with|font-size|1.19|<\with|par-mode|right>
    Responsable d'UV: M. Petitjean

    Responsable de sujet: M. Bachard
  </with>>

  <assign|page-this-footer|Semestre de printemps 2004>

  <page-break>

  \;

  \;

  \;

  \;

  \;

  \;

  \;

  \;

  <\with|par-mode|center>
    <section|Remerciements>
  </with>

  \;

  \;

  \ \ \ Nous souhaitons tout d'abord remercier M. Petitjean et M. Bachard,
  pour nous avoir permis de réaliser cette UV et d'étudier un sujet nous
  intéressant particulièrement. Nous remercions aussi M. Lannuzel, pour sa
  disponibilité et pour les documents MT26 fournis. Bien que cela soit
  difficile, nous voudrions remercier également tous les anonymes qui ont
  apporté des réponses à nos différentes interrogations, sur les forums
  d'Axiom et de GNUplot, au cours des derniers mois.
  <assign|page-this-footer|AC20: Utilisation de logiciels libres>

  <page-break><assign|page-this-footer|AC20: Utilisation de logiciels libres>

  \;

  \;

  \;

  \;

  <\with|par-mode|center>
    <section|Introduction>
  </with>

  \;

  \;

  \;

  \ \ \ Le recours au calcul formel est une notion primordiale au cours des
  études d'un élève ingénieur. Actuellement, au sein de l'UTBM, Maple,
  logiciel \S star \T de calcul formel tiens cette place prédominante:
  Facilité d'emploi, aide complète, interface détaillée et intuitive, rien ne
  lui fait défaut: Et pourtant, MAPLE est un logiciel propriétaire, donc
  fermé. Il est payant, et très onéreux. (La version actuelle de Maple 9.5
  coûte environ 995 <euro> l'unité, pour une utilisation dans le domaine
  éducatif) Il est ainsi quasi-impossible pour un étudiant de se procurer une
  version \S légale \T du logiciel: On trouve bon nombre de copies en libre
  circulation.

  \ \ \ MT26 est une UV mathématique ou l'on se sert de Maple pour résoudre
  une série de problèmes graphiques, et arithmétiques: Ces problèmes sont
  diversifiés (limites, sommes, matrices, études de fonctions,
  programmation..) et peuvent tous être résolus au cours du semestre avec une
  intervention minimale du professeur.

  \ \ \ L'intitulé de notre AC20, \S Utilisation de logiciels libres pour la
  réalisation de TPs MT26 \T va nous conduire à chercher des solutions
  alternatives à Maple, à les tester, à définir leur facilité d'utilisation,
  et enfin à juger de leur capacité à devenir des logiciels d'enseignement
  pédagogique. Cette démarche pourra par la suite de permettre aux étudiants
  de découvrir la capacité qu'ont les logiciels libres à se rapprocher
  étonnamment des logiciels propriétaires, tout en profitant des avantages
  liés à ceux-ci.

  \ \ \ Ce document est placé sous la license dite libre FDL. Vous trouverez
  une version complète de cette license en annexe.

  \;

  <page-break> \ \ 

  <assign|page-this-footer|AC20: Utilisation de logiciels libres>

  <\table-of-contents|toc>
    \;

    Introduction

    Déterminati<assign|page-nr|1>on des logiciels
    utilisés<value|toc-dots><pageref|toc-3>

    Présentation générale des logiciels<value|toc-dots><pageref|toc-4>

    <with|par-left|1.5fn|Axiom Computer Algebra
    System<value|toc-dots><pageref|toc-5>>

    <with|par-left|1.5fn|GNUplot<value|toc-dots><pageref|toc-6>>

    Informations sur les logiciels<value|toc-dots><pageref|toc-7>

    <with|par-left|1.5fn|Axiom<value|toc-dots><pageref|toc-8>>

    <with|par-left|1.5fn|GNUplot<value|toc-dots><pageref|toc-9>>

    Ergonomie: Prise en main<value|toc-dots><pageref|toc-10>

    <with|par-left|1.5fn|Axiom<value|toc-dots><pageref|toc-11>>

    <with|par-left|3fn|Mode Console<value|toc-dots><pageref|toc-12>>

    <with|par-left|3fn|Intégration à TeXmacs<value|toc-dots><pageref|toc-13>>

    <with|par-left|1.5fn|GNUplot<value|toc-dots><pageref|toc-14>>

    <with|par-left|3fn|Prise en main<value|toc-dots><pageref|toc-15>>

    <with|par-left|3fn|Intégration dans TeXmacs<value|toc-dots><pageref|toc-16>>

    Prise en main du logiciel<value|toc-dots><pageref|toc-17>

    <with|par-left|1.5fn|Axiom<value|toc-dots><pageref|toc-18>>

    <with|par-left|3fn|Premiers pas<value|toc-dots><pageref|toc-19>>

    <with|par-left|3fn|Recherche de solutions<value|toc-dots><pageref|toc-20>>

    <with|par-left|1.5fn|GNUplot<value|toc-dots><pageref|toc-21>>

    <with|par-left|3fn|Premiers pas<value|toc-dots><pageref|toc-22>>

    <with|par-left|3fn|Recherche de solutions<value|toc-dots><pageref|toc-23>>

    Résolution des TPs MT26<value|toc-dots><pageref|toc-24>

    <with|par-left|1.5fn|Instructions Maple<value|toc-dots><pageref|toc-25>>

    <with|par-left|3fn|Instructions d'algèbre<value|toc-dots><pageref|toc-26>>

    <with|par-left|3fn|Instructions d'analyse<value|toc-dots><pageref|toc-27>>

    <with|par-left|3fn|Instructions d'algèbre
    linéaire<value|toc-dots><pageref|toc-28>>

    <with|par-left|1.5fn|Graphiques<value|toc-dots><pageref|toc-29>>

    <with|par-left|3fn|Courbes dans le plan<value|toc-dots><pageref|toc-30>>

    <with|par-left|3fn|Surfaces dans l'espace<value|toc-dots><pageref|toc-31>>

    <with|par-left|1.5fn|Programmation<value|toc-dots><pageref|toc-32>>

    <with|par-left|3fn|Suites<value|toc-dots><pageref|toc-33>>

    <with|par-left|3fn|Sommes de séries<value|toc-dots><pageref|toc-34>>

    <with|par-left|3fn|Arithmétique<value|toc-dots><pageref|toc-35>>

    <with|par-left|3fn|Algèbre<value|toc-dots><pageref|toc-36>>

    <with|par-left|3fn|Procédures<value|toc-dots><pageref|toc-37>>

    <with|par-left|1.5fn|Calculs du programme
    MT26<value|toc-dots><pageref|toc-38>>

    Conclusion <value|toc-dots><pageref|toc-39>

    Annexes<value|toc-dots><pageref|toc-40>
  </table-of-contents>

  <page-break><assign|page-nr|1>

  <\with|par-mode|center>
    <section|Déterminati<assign|page-nr|1>on des logiciels utilisés>
  </with>

  \ \ \ Les contraintes imposées lors de la définition du sujet (portabilité,
  gratuité) nous ont amené à choisir 2 logiciels différents pour l'étude de
  la problématique: l'un étant spécifique au graphisme, et l'autre au calcul
  formel utilisé dans Maple.

  \ \ \ Notre premier choix s'est ainsi porté sur GNUplot, logiciel de tracé
  très utilisé dans le monde du libre, tandis que la résolution des exercices
  de calcul et de programmation se fera avec Axiom (Axiom Computer Algebra
  System). Ce dernier est en effet un des logiciels libres de calcul formel
  les plus complets à l'heure actuelle.

  \ \ \ Ces deux logiciels répondent aux contraintes imposées : Ceux-ci sont
  libres, et compilable sur de multiple systèmes d'exploitation, tels que
  Linux, MacOs, Solaris, Windows. Ils sont tous les deux au moins en licence
  GPL. Les versions binaires sont disponibles pour chacun des systèmes,
  excepté en ce qui concerne Windows, la compilation pouvant se révéler très
  longue et fastidieuse.

  \ \ \ Nous utiliserons pour des raisons pratiques un PC, avec un système
  d'exploitation Linux Debian. L'interface graphique utilisée, KDE, ne posera
  aucun problèmes. Ce système nous permet d'installer, de configurer, et
  d'utiliser les 2 logiciels avec une grande facilité.

  <\with|par-mode|center>
    <section|Présentation générale des logiciels>
  </with>

  <subsection|Axiom Computer Algebra System>

  \ \ \ Axiom est un logiciel utile pour la recherche et le développement
  d'algorithmes mathématiques. Il définit une hiérarchie de types
  mathématiquement correcte, fortement typée. Il a un langage de
  programmation et un compilateur intégrés, ce qui lui confère rapidité
  d'exécution et souplesse d'utilisation.

  \ \ \ Axiom est développé depuis 1973 et fut autrefois vendu comme un
  produit commercial. Il est aujourd'hui publié comme logiciel libre.

  \ \ \ Des efforts sont en cours pour étendre ce logiciel en :

  <\itemize>
    <item>développant une meilleure interface utilisateur

    <item>le rendant utilisable comme outil d'enseignement

    <item>développant un protocole de serveur algébrique

    <item>intégrant des fonctions mathématiques supplémentaires

    <item>reconstruisant l'algèbre dans un style de programmation littéraire

    <item>intégrant la programmation logique

    <item>développant un journal d'Axiom avec comité de lecture.
  </itemize>

  <page-break>

  <subsection|GNUplot>

  \ GNUplot permet quand à lui de créer des graphes qui peuvent être intégrés
  à des documents.

  \ \ \ Le logiciel reconnaît la plupart des fonctions mathématiques de base
  ( trigonométrique, Bessel, etc.) et permet de tracer des courbes dans bon
  nombre de repères (logarithmiques, polaires, paramétriques, 3D). Il est
  également possible de créer des graphes à partir de fichiers de données.
  Cette notion est l'aspect mis en avant: En effet, GNUplot n'est absolument
  pas un logiciel de calcul numérique: Les études de fonction sont réduites à
  leur minimum.

  \ \ \ Il s'agit d'un logiciel très léger ( 3 mo environ ) et utilisable sur
  de multiples systèmes d'exploitation. Des tutoriels, fichiers d'aides, et
  version binaires sont disponibles pour tous systèmes.

  <\with|par-mode|center>
    <section|Informations sur les logiciels>
  </with>

  <subsection|Axiom>

  \ \ \ Axiom est basé sur une licence BSD modifiée. Elle est courte (environ
  1 page), et se révèle donc facile à lire. Il n'y a pas de clauses
  difficiles à comprendre comme dans d'autres licences. Cette licence accorde
  :

  <\itemize-arrow>
    <item>Le droit d'exécuter le programme quel que soit les intentions ou le
    but

    <item>Le droit d'étudier le code source du programme

    <item>Le droit de modifier le code source

    <item>Le droit de publier les modifications

    <item>Le droit d'intégrer une partie du code dans un logiciel non-libre,
    et ce sans contraintes. Ce dernier aspect, même s'il favorise
    l'interopérabilité des softwares, peut dans une certaine mesure nuire au
    libre.
  </itemize-arrow>

  \ \ \ La version actuelle est la version 4. C'est une version bêta,
  suffisamment stable pour en permettre une utilisation régulière. Quelques
  bugs subsistent toutefois.

  \ \ \ Le développement d'Axiom est actuellement assuré par la collaboration
  de d'une centaine de programmeurs, essentiellement dirigés par une équipe
  de 7 personnes.

  <tabular|<tformat|<table|<row|<cell|Tim Daly>>|<row|<cell|David
  Mentré>>|<row|<cell|Camm Maguire>>|<row|<cell|Juergen
  Weiss>>|<row|<cell|Bill Page>>|<row|<cell|Dylan Thurston>>>>>

  \ \ \ La liste de tous les programmeurs est visible grâce à la commande
  )credits, dans axiom.

  <page-break>

  <subsection|GNUplot>

  \ \ \ Le développement de GNUplot est à l'heure actuelle très ralenti : En
  effet, la version disponible (Version 4.0) semble satisfaire les
  développeurs ainsi que la majorité des utilisateurs. Les principaux
  développeurs à l'heure actuelle sont :

  <tabular|<tformat|<table|<row|<cell|Alexander Mai>>|<row|<cell|Alex C.
  Woo>>|<row|<cell|Hans-Bernhard Broeker>>|<row|<cell|Clark
  Gaylord>>|<row|<cell|Johannes Zellner>>|<row|<cell|Lars
  Hecking>>|<row|<cell|Petr Mikulik>>|<row|<cell|Per
  Persson>>|<row|<cell|Ethan Merritt>>|<row|<cell|James R. Van Zandt>>>>>

  \ \ \ La licence de GNUplot est une licence GPL. Cette licence accorde 4
  libertés principales:

  <\itemize-arrow>
    <item>Le droit d'exécuter le programme quel que soit les intentions ou le
    but

    <item>Le droit d'étudier le code source du programme

    <item>Le droit de modifier le code source

    <item>Le droit de publier les modifications
  </itemize-arrow>

  \ \ \ Contrairement à la licence BSD d'Axiom, elle implique que toute
  utilisation du code dans une autre application force cette autre
  application à être elle aussi compatible avec la licence GPL.

  <\with|par-mode|center>
    <section|Ergonomie: Prise en main>
  </with>

  <subsection|Axiom>

  <subsubsection|Mode Console>

  \ \ \ La prise en main graphique d'Axiom peut s'avérer très déroutante au
  début pour un utilisateur habitué à Windows, et ce pour différentes
  raisons:

  <\itemize>
    <item>Pas de menus apparent

    <item>Peu attractif graphiquement (car en mode console)

    <item>Pas d'interface intégrée au logiciel.

    <item>Les chargements des librairies sont affichés entre le calcul et le
    résultat, ce qui fait que les résultats apparaissent parfois plusieurs
    pages après le calcul !
  </itemize>

  <big-figure|<postscript|mt26/photo1.jpg|*3/4|*3/4||||>|Exemple de calcul>

  \ \ \ L'utilisation du mode console est donc très peu attractif : les
  racines, matrices, et autres formules complexes apparaissent en mode ASCII,
  ce qui rend la lecture des résultats difficile, et exige parfois une
  certaine gymnastique visuelle afin de réussir à trouver le résultat
  correct.

  \ \ \ Toutefois une alternative existe à ce problème : L'utilisation
  supplémentaire du logiciel GNU TeXmacs et l'utilisation de son plugin
  intégré Axiom.

  <subsubsection|Intégration à TeXmacs>

  1) Présentation de TeXmacs

  \ \ \ TeXmacs se définit comme un éditeur WYSIWYG (what you see is what you
  get) de textes scientifiques : ce que vous voyez à l'écran est identique à
  ce que vous obtenez à l'impression. TeXmacs permet l'édition de textes
  structurés et présente beaucoup de caractéristiques qui le rendent
  extrêmement attrayant :

  <\itemize>
    <item>Interface conviviale et assez facile à maîtriser. Il faudra
    cependant s'habituer à la différence de "philosophie" qui l'anime,
    vis-à-vis des traitements de texte plus classiques comme ceux de
    MS-Office et OpenOffice, où la notion de document structuré est peu
    employée. Il faut noter que TeXmacs n'est pas compatible avec les formats
    de traitement de textes habituels ( doc, rtf... )

    <item> Interfaçage avec des plusieurs logiciels libres de calcul
    numérique ou formel. TeXmacs 1.0 possède actuellement en standard une
    interface pour les logiciels de calcul de même que pour un interpréteur
    du langage Scheme. TeXmacs est donc un logiciel libre de traitement de
    textes qui \ sait calculer.

    <item>Utilisation de polices de type vectoriel, permettant un affichage
    extrêmement agréable à l'écran, et une impression papier de très haute
    qualité. Les polices utilisées ne sont pas les polices TrueType
    habituelles des systèmes d'exploitation propriétaires, mais celles du
    système de formatage de textes TeX/LaTeX (très répandu dans le monde
    scientifique, où, de fait, TeX/LaTeX est devenu le standard). Gestion
    très étendue des symboles mathématiques avec un éditeur de formules
    intégré.\ 

    <item>Possibilité d'insertion d'images et de documents graphiques, par de
    simples manipulations avec la souris Import et export à partir et vers
    des documents au format texte, LaTeX et html.

    <item>Il est possible de changer la langue de TeXmacs, afin d'obtenir une
    version une exécution en français de celui-ci: Même si l'intérêt est
    limité ( on ne se servira pas du tout des menus ) l'impact psychologique
    de se retrouver en terrain connu est non négligeable.
  </itemize>

  <big-figure|<inactive|><inactive|><postscript|mt26/photo3.jpg|*5/8|*5/8||||>|Impression
  écran du logiciel TeXmacs>

  <page-break>

  2) Intégration d'Axiom à TeXmacs

  \;

  \ \ \ L'intégration d'Axiom dans TeXmacs se fait très simplement, même pour
  un débutant en informatique : Le logiciel détecte automatiquement la
  présence d'Axiom, et propose via un menu l'ouverture d'une session Axiom :
  Après validation, une \S zone de script \T apparaît, et permet la saisie
  des formules mathématiques.

  \;

  3) Modifications apportées par TeXmacs

  \ \ \ L'amélioration graphique apportée par TeXmacs est loin d'être
  négligeable. Plusieurs aspects et inconvénients d'Axiom sont ainsi
  corrigés:

  <\itemize>
    <item>Lissage des polices

    <item>Résultats des calculs très lisibles, structurés

    <item>Coloration des calculs, résultats, types pour une différentiation
    plus aisée.

    <item>Chargement des différentes librairies en arrière plan : pas
    d'affichage intempestif.
  </itemize>

  <big-figure|<postscript|mt26/photo2.jpg|*5/8|*5/8||||>|Utilisation d'une
  session Axiom dans TeXmacs>e\ 

  \ \ \ Le carré bleu extérieur symbolise la session Axiom, les parties bleu
  foncé le calcul, les parties marron le type du résultat, et le chiffre à
  droite du résultat, un historique de calcul ( on saura ainsi dans quel
  ordre on a effectué les calculs )

  <subsection|GNUplot>

  <subsubsection|Prise en main>

  \ \ \ La présentation graphique dépend du système d'exploitation : Sous
  Linux, tout menu est inexistant, alors que dans la version Windows, une
  série de menus permet de ne pas être \S perdu \T au lancement de
  l'application. Ainsi, la difficulté aux premiers abords dépend de la
  version utilisée.

  \ \ \ L'utilisation de GNUplot, contrairement à Axiom, est impossible de
  façon pratique sans terminal graphique: Il est néanmoins possible
  d'exporter la courbe dans un fichier PostScript, latex, pdf, ou gif mais la
  visualisation de la courbe exige un environnement graphique: \ Il existe un
  composant supplémentaire, non fourni avec celui de base, dans le package
  GNUplot-x11. Ce package permet la création d'une fenêtre d'affichage,
  externe à la console. Celle ci ouvre ainsi une fenêtre de pré-visualisation
  à la demande d'affichage de la courbe.

  <big-figure|<postscript|mt26/photo4.jpg|*5/8|*5/8||||>| Exemple d'affichage
  d'une courbe ( Environnement KDE )>

  <subsubsection|Intégration dans TeXmacs>

  \;

  \ \ \ Tout comme Axiom, l'intégration d'une session GNUplot est possible
  dans TeXmacs. Néanmoins, l'avantage est bien plus limité,

  <\itemize>
    <item>Il est impossible de faire évoluer, tourner les graphiques, une
    fois qu'ils ont été tracés.

    <item>Il est impossible d'afficher les couleurs sur les graphiques, ce
    qui pose un problème lors d'affichage de plusieurs courbes en simultané.
    Ceci est du à l'utilisation du script TeXmacs : en effet celui-ci utilise
    un fichier d'exportation L<rsup|A>T<rsub|E>X et non PostScript.
    L'inconvénient est majeur car le format L<rsup|A>T<rsub|E>X exporté par
    GNUplot ne permet pas ou du moins pas aisément, une utilisation de la
    couleur.

    <item>Il se révèle qu'entre chaque ligne tapée, toute variable,
    enregistrement, et paramètre enregistré se retrouve effacé, ce qui est
    très désavantageux: Il est impossible de déclarer une fonction, puis de
    l'afficher. Pour remédier à cela, on tapera toutes les commandes à la
    suite les unes des autres, tout en les séparant par des points virgules.
  </itemize>

  \ \ \ Pourtant, nous utiliserons cette méthode dans la résolution de la
  problématique car elle présente certains avantages :

  <\itemize>
    <item>Possibilité d'intercaler une session Axiom avec une session
    GNUplot.

    <item>Interaction simplifiées entre les 2 logiciels.

    <item>Facilité de mise en page du présent rapport
  </itemize>

  <page-break>

  <\with|par-mode|center>
    <section|Prise en main du logiciel>
  </with>

  <subsection|Axiom>

  <subsubsection|Premiers pas>

  \ \ \ Axiom possède comme tout logiciel, certains avantages et certains
  inconvénients.

  \ \ \ Le principal avantage est l'intuitivité du nom de la majorité des
  fonctions : Le nom de la fonction permet en général de comprendre l'utilité
  de la fonction en elle-même. Un système \Sd'aide\T permet de découvrir les
  arguments à fournir à la fonction. Un système d'auto détection des
  arguments fournis à la fonction permet de choisir entre différentes
  utilisations de la fonction : On pourra ainsi utiliser integrate(f) tout
  comme integrate(f(x),x).

  \ \ \ L'inconvénient majeur réside pourtant dans le système d'aide : il
  n'existe pas de regroupement par catégories des fonctions (comme dans Maple
  par exemple) De plus le fonctionnement de celles-ci n'est pas expliqué, et
  les tutoriels existant sont très limités dans leur champ d'application. Il
  n'existe pas de texte explicatif, comme dans Maple, pour chaque fonction.

  <subsubsection|Recherche de solutions>

  \ \ \ La recherche de solutions est souvent longue et fastidieuse pour
  Axiom : Les ressources sur internet sont maigres, et en général assez mal
  détaillées. Lorsque l'on bloque sur un problème, le fichier d'aide est
  totalement inutile. Les solutions aux problèmes sont donc souvent très
  difficiles à trouver. Il existe cependant un moyen de résoudre certains
  blocages : On peut faire un certain rapprochement avec Maple, beaucoup de
  commandes étant similaires à ce dernier.

  <subsection|GNUplot>

  <subsubsection|Premiers pas>

  \ \ \ GNUplot a l'avantage de permettre une prise en main immédiate après
  lecture du fichier d'aide (et des tutoriels). Les fonctions sont simples et
  logiques et permettent d'obtenir des résultats très rapidement.

  <subsubsection|Recherche de solutions>

  \ \ \ On ne bloque jamais bien longtemps sur un problème. Les ressources
  sur internet sont abondantes et détaillées, le fichier d'aide est correct.
  On ne relève pas de difficultés majeures à l'utilisation générale de
  GNUplot.

  <page-break>

  <\with|par-mode|center>
    <section|Résolution des TPs MT26>
  </with>

  <\with|prog-language|axiom|prog-session|default>
    <\with|par-mode|center>
      <subsection|Instructions Maple>
    </with>

    <subsubsection|Instructions d'algèbre>

    1) Soit le polynôme P(x)= x<with|mode|math|<rsup|3>> - 3x + 2. En
    déterminer les racines réelles ou complexes et factoriser P. Déterminer
    le polynôme dérivé et les décompositions en éléments simples des
    fractions rationnelles Q1(x) = <with|mode|math|<frac|1|P(x)>> et Q2(x)=
    <with|mode|math|<frac|P<rprime|'>(x)|P(x)>>.\ 

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      P:=x^3-3*x+2
    </input>

    <\output>
      <with|mode|math|math-display|true|x<rsup|3>-3x+2<leqno>(128)>

      <axiomtype|Polynomial Integer >
    </output>

    \ \ \ On découvre ici la structure générale du calcul sous Axiom: En
    rouge, l'invite de de commande. en bleu, le calcul demandé. En noir en
    dessous le résultat. à droite, entre parenthèses, le \S numéro \T de
    calcul, suivi du type de résultat. Pour des raisons de place, on fera
    abstraction du type retourné par la fonction.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )set messages type off
    </input>

    \ \ \ On résout l'équation <with|mode|math|x<rsup|3>-3x+2=0>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      solve(P=0,x)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[>x=1,<space|0.5spc>x=-2<right|]><leqno>(129)>
    </output>

    \ \ \ On factorise P

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factor(P)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|(>x-1<right|)><rsup|2><left|(>x+2<right|)><leqno>(130)>
    </output>

    \ \ \ On calcule sa dérivée

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      differentiate(P)
    </input>

    <\output>
      <with|mode|math|math-display|true|3x<rsup|2>-3<leqno>(131)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      Q1:=1/P
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|1|x<rsup|3>-3x+2><leqno>(132)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      Q2:=differentiate(P)/P
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|3|x<rsup|3>-3x+2>x<rsup|2>-<frac|3|x<rsup|3>-3x+2><leqno>(133)>
    </output>

    \;

    \ \ \ Pour décomposer la fonction en éléments simples, on utilise ici une
    syntaxe particulière : \S ::UP(x, FRAC INT) \ \T. La fonction
    partialFraction prend en effet en paramètres 2 arguments de type
    Univariate Polynomial ( UP ) or P est un polynôme Fraction Integer. On
    effectue ainsi le changement demandé : ::NOUVEAUTYPE(variable,
    ANCIENTYPE)

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      partialFraction(1,P::UP(x, FRAC INT))
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|-<frac|1|9>x+<frac|4|9>|<left|(>x-1<right|)><rsup|2>>+<frac|<frac|1|9>|x+2><leqno>(134)>

      \;
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      partialFraction(differentiate(P),P::UP(x, FRAC INT))
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|2|x-1>+<frac|1|x+2><leqno>(135)>
    </output>

    2) Même exercice pour P1(x)=x<with|mode|math|<rsup|3>>-3x<with|mode|math|<rsup|2>>+2x,
    P2(x)=x<with|mode|math|<rsup|4>>+1 et
    P3(x)=<with|mode|math|<sqrt|2>>(x<with|mode|math|<rsup|4>>+1). Étudier la
    différence entre les deux derniers cas et expliquer pourquoi.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      P1:=x^3-3*x^2+2*x
    </input>

    <\output>
      <with|mode|math|math-display|true|x<rsup|3>-3x<rsup|2>+2x<leqno>(136)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      P2:=x^4+1
    </input>

    <\output>
      <with|mode|math|math-display|true|x<rsup|4>+1<leqno>(137)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      P3:=sqrt(2)*(x^4+1)
    </input>

    <\output>
      <with|mode|math|math-display|true|<sqrt|2>x<rsup|4>+<sqrt|2><leqno>(138)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factor(P1)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|(>x-2<right|)><left|(>x-1<right|)>x<leqno>(139)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factor(P2)
    </input>

    <\output>
      <with|mode|math|math-display|true|x<rsup|4>+1<leqno>(140)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factor(P3)
    </input>

    <\output>
      <with|mode|math|math-display|true|<sqrt|2><left|(>x<rsup|4>+1<right|)><leqno>(141)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      partialFraction(1,P1::UP(x, FRAC INT))
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|<frac|1|2>|x-2>-<frac|1|x-1>+<frac|<frac|1|2>|x><leqno>(15)>

      <axiomtype|PartialFraction UnivariatePolynomial(x,Fraction Integer) >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      partialFraction(1,P2::UP(x, FRAC INT))
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|1|x<rsup|4>+1><leqno>(16)>

      <axiomtype|PartialFraction UnivariatePolynomial(x,Fraction Integer) >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      partialFraction(1,P3::UP(x, FRAC AN))
    </input>

    <\output>
      \ \ \ UnivariatePolynomial(x,Fraction AlgebraicNumber) is not a valid\ 

      \ \ \ \ \ \ type.
    </output>

    3) Résolution des systèmes:

    \ \ \ \ \ \ \ \ 3x+4y-z=12

    (S1) \ x - y+2z=-3

    \ \ \ \ \ \ \ \ x+y+z=2

    \;

    \ \ \ On doit basculer tous les termes de l'égalité du même coté, afin
    d'avoir un systèmes d'équations, sans secondes membres. La résolution se
    fait pas l'intermédiaire d'une liste d'équations.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      solve([3*x+4*y-z-12, x-y+2*z+3 , x+y+z-2],[x,y,z])
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>x=1,<space|0.5spc>y=2,<space|0.5spc>z=-1<right|]><right|]><leqno>(17)>
    </output>

    \ \ \ \ \ \ \ \ 3x+4y-z=12

    S(2) \ x-y+2z=-3

    \ \ \ \ \ \ \ 4x+3y+z=9

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      solve([3*x+4*y-z-12, x-y+2*z+3 , 4*x+3*y+z-9],[x,y,z])
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>x=-%B,<space|0.5spc>y=%B+3,<space|0.5spc>z=%B<right|]><right|]><leqno>(18)>
    </output>

    4) Briseurs de codes

    a) les nombres suivants sont-ils premiers ? Noter le temps de calcul pour
    chacun d'eux.

    \ \ \ Pour ne pas avoir à calculer le temps de calcul manuellement, on
    active l'option temps de calcul. Ce temps de calcul est mesuré par le
    moteur d'Axiom, et non celui de TeXmacs, ce qui résulte un décalage entre
    le temps annoncé et le temps mesuré. L'affichage sur de très nombreuses
    lignes est un facteur d'erreur.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )set messages time on
    </input>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      prime?(58358298767740033)
    </input>

    <\output>
      <with|mode|math|math-display|true|f*a*l*s*e<leqno>(19)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.01 (OT) = 0.01 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      prime?(408506280913741802317)
    </input>

    <\output>
      <with|mode|math|math-display|true|t*r*u*e<leqno>(20)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      prime?(factorial(30)+1)
    </input>

    <\output>
      <with|mode|math|math-display|true|f*a*l*s*e<leqno>(21)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      prime?(131124424344439150898996787974484867)
    </input>

    <\output>
      <with|mode|math|math-display|true|f*a*l*s*e<leqno>(22)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.01 (OT) = 0.01 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      prime?(7719068319927551)
    </input>

    <\output>
      <with|mode|math|math-display|true|t*r*u*e<leqno>(23)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      prime?(834384970974248697794)
    </input>

    <\output>
      <with|mode|math|math-display|true|f*a*l*s*e<leqno>(24)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factors(58358298767740033)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>f*a*c*t*o*r=563,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=3233509,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=32056799,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]><right|]><leqno>(25)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time: 0.01 (IN) + 0.01 (OT) + 0.08
      (GC) = 0.10 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factors(factorial(30)+1)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>f*a*c*t*o*r=31,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=12421,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=82561,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=1080941,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=7719068319927551,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]><right|]><leqno>(26)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time: 0.03 (IN) +
      0.01 (OT) + 0.12 (GC) = 0.16 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factors(131124424344439150898996787974484867)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>f*a*c*t*o*r=3,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=947,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=32165873,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=1434884743560008132693419,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]><right|]><leqno>(27)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.03 (IN) + 0.12 (GC) = 0.15 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factors(834384970974248697794)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>f*a*c*t*o*r=2,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=7,<space|0.5spc>e*x*p*o*n*e*n*t=2<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=1103,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]>,<space|0.5spc><left|[>f*a*c*t*o*r=7719068319927551,<space|0.5spc>e*x*p*o*n*e*n*t=1<right|]><right|]><leqno>(28)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.01 (IN) + 0.04 (GC) = 0.05 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )set messages time off
    </input>

    Note: Les réponses aux calculs sont quasi-instantanés.

    <subsubsection|Instructions d'analyse>\ 

    1) Calculs de sommes

    a) Calculer pour plusieurs valeurs de n, puis dans le cas général, la
    somme <with|mode|math|>Sn=<with|mode|math|<big|sum><rsup|n><rsub|k=1>k<rsup|2>>
    et vérifier la relation Sn=<with|mode|math|<frac|n(n+1)(2n+1)|6>>

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      <with|mode|math|sum(k^2,k=1..5)>
    </input>

    <\output>
      <with|mode|math|math-display|true|55<leqno>(30)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      sum(k^2,k=1..n)
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|2n<rsup|3>+3n<rsup|2>+n|6><leqno>(31)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      (n)*(n+1)*(2*n+1)
    </input>

    <\output>
      <with|mode|math|math-display|true|2n<rsup|3>+3n<rsup|2>+n<leqno>(32)>
    </output>

    2) Calculer les limites suivantes

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      limit((sqrt(1+x)*sin(x)+log(1-x))/(x-sin(x)),x=0)
    </input>

    <\output>
      <with|mode|math|math-display|true|-<frac|15|4><leqno>(33)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      limit((x^2*(1+1/x)^x-%e*x^3*log(1+1/x)),x=%plusInfinity)
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|e|8><leqno>(34)>

      \;
    </output>

    3) Calcul d'intégrales et de primitives

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      integrate((x+1)/(x^2+1),x=0..1)
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|2log
      <left|(>2<right|)>+\<pi\>|4><leqno>(35)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      integrate((x+1)/(x^2+1),x=0..%plusInfinity)
    </input>

    <\output>
      <with|mode|math|math-display|true|+\<infty\><leqno>(36)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      integrate(1/(x^2+4),x=0..%plusInfinity)
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|\<pi\>|4><leqno>(37)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      integrate((x+1)/(x^2+1),x)
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|log
      <left|(>x<rsup|2>+1<right|)>+2arctan <left|(>x<right|)>|2><leqno>(38)>
    </output>

    \;

    4) Intégrer par partie, puis calculer.

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      integrate(x^2*sin(x),x)
    </input>

    <\output>
      <with|mode|math|math-display|true|2x*sin
      <left|(>x<right|)>+<left|(>-x<rsup|2>+2<right|)>cos
      <left|(>x<right|)><leqno>(39)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      integrate(x^2*sin(x),x=0..%pi)
    </input>

    <\output>
      <with|mode|math|math-display|true|\<pi\><rsup|2>-4<leqno>(40)>
    </output>

    4 ) Effectuer un changement de variable

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      integrate(x/sqrt(4-9*x^2),x)
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|x<rsup|2>|<sqrt|-9x<rsup|2>+4>-2><leqno>(41)>

      <axiomtype|>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      subst(integrate(x/sqrt(4-9*x^2),x),[x=sqrt(t)])
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|t|<sqrt|-9t+4>-2><leqno>(42)>
    </output>

    5) Développements limités

    \ \ \ On active l'option streams en niveau 5: Cela signifie que les
    développements limités vont être réalisés à l'ordre 5. En théorie, le
    dernier argument de series sert à cela, mais le résultat est incorrect.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )set streams calculate 5
    </input>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      series(tan(x),x=0,5)
    </input>

    <\output>
      <with|mode|math|math-display|true|x+<frac|1|3>x<rsup|3>+<frac|2|15>x<rsup|5>+O<left|(>x<rsup|7><right|)><leqno>(43)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      series(log(tan(x)),x=0)
    </input>

    <\output>
      <\with|mode|math|math-display|true>
        log <left|(>x<right|)>+<frac|1|3>x<rsup|2>+<frac|7|90>x<rsup|4>+O<left|(>x<rsup|6><right|)><leqno>(44)
      </with>
    </output>

    \;

    6) Calcul différentiel

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      f:= operator('f);
    </input>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      x^2*D(f(x),x)+f(x)=0
    </input>

    <\output>
      <with|mode|math|math-display|true|x<rsup|2>f<rsub|
      ><rsup|,><left|(>x<right|)>+f<left|(>x<right|)>=0<leqno>(46)>

      \;
    </output>

    On utilise % pour rappeler le résultat du dernier calcul. Ici %
    correspond à <with|mode|math|x<rsup|2>f<rsub|
    ><rsup|,><left|(>x<right|)>+f<left|(>x<right|)>=0>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      solve(%,f,x)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[>p*a*r*t*i*c*u*l*a*r=0,<space|0.5spc>b*a*s*i*s=<left|[>e<rsup|<frac|1|x>><right|]><right|]><leqno>(47)>
    </output>

    7) Calculer pour des valeurs simples de a, les sommes
    <with|mode|math|<big|sum><rsup|\<infty\>><rsub|x=1>><with|mode|math|<frac|1|x<rsup|a>>>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      n:=5
    </input>

    <\output>
      <with|mode|math|math-display|true|5<leqno>(48)>
    </output>

    \ \ \ Le calcul d'une somme de série lorsque celle-ci tend vers l'infini,
    et cela même si elle converge, est impossible dans Axiom. Les domaines
    infinis ne sont pas pris en charge.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      sum(1/x^n,x=1..%plusInfinity)
    </input>

    <\output>
      \ \ \ There are 6 exposed and 2 unexposed library operations named sum\ 

      \ \ \ \ \ \ having 2 argument(s) but none was determined to be
      applicable.\ 

      \ \ \ \ \ \ Use HyperDoc Browse, or issue

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ )display
      op sum

      \ \ \ \ \ \ to learn more about the available operations. Perhaps\ 

      \ \ \ \ \ \ package-calling the operation or using coercions on the
      arguments

      \ \ \ \ \ \ will allow you to apply the operation.

      \ 

      \ \ \ Cannot find a definition or applicable library operation named
      sum\ 

      \ \ \ \ \ \ with argument type(s)\ 

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Fraction Polynomial
      Integer

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ SegmentBinding OrderedCompletion
      Integer

      \ \ \ \ \ \ 

      \ \ \ \ \ \ Perhaps you should use "@" to indicate the required return
      type,\ 

      \ \ \ \ \ \ or "$" to specify which version of the function you need.
    </output>

    <subsubsection|Instructions d'algèbre linéaire>

    1) Réduction des matrices

    a) Saisir la matrice M, en calculer le déterminant, puis l'inverse

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>>>>
      m:=matrix [[4,-1,-1],[-1,4,-1],[-1,-1,4]]
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<cwith|1|-1|2|2|cell-halign|c>|<cwith|1|-1|3|3|cell-halign|c>|<table|<row|<cell|4>|<cell|-1>|<cell|-1>>|<row|<cell|-1>|<cell|4>|<cell|-1>>|<row|<cell|-1>|<cell|-1>|<cell|4>>>>><right|]><leqno>(49)>
    </output>

    On réutilise % pour appeler le dernier résultat.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      determinant(%)
    </input>

    <\output>
      <with|mode|math|math-display|true|50<leqno>(50)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      m^-1
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<cwith|1|-1|2|2|cell-halign|c>|<cwith|1|-1|3|3|cell-halign|c>|<table|<row|<cell|<frac|3|10>>|<cell|<frac|1|10>>|<cell|<frac|1|10>>>|<row|<cell|<frac|1|10>>|<cell|<frac|3|10>>|<cell|<frac|1|10>>>|<row|<cell|<frac|1|10>>|<cell|<frac|1|10>>|<cell|<frac|3|10>>>>>><right|]><leqno>(51)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      characteristicPolynomial(m, x)
    </input>

    <\output>
      <with|mode|math|math-display|true|-x<rsup|3>+12x<rsup|2>-45x+50<leqno>(52)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      solve(%=0,x)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[>x=5,<space|0.5spc>x=2<right|]><leqno>(53)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      eigenvectors(m)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>e*i*g*v*a*l=2,<space|0.5spc>e*i*g*m*u*l*t=1,<space|0.5spc>e*i*g*v*e*c=<left|[><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|1>>|<row|<cell|1>>|<row|<cell|1>>>>><right|]><right|]><right|]>,<space|0.5spc><left|[>e*i*g*v*a*l=5,<space|0.5spc>e*i*g*m*u*l*t=2,<space|0.5spc>e*i*g*v*e*c=<left|[><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|-1>>|<row|<cell|1>>|<row|<cell|0>>>>><right|]>,<space|0.5spc><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|-1>>|<row|<cell|0>>|<row|<cell|1>>>>><right|]><right|]><right|]><right|]><leqno>(54)>
    </output>

    \;

    2) Même question pour une autre matrice

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      m1 := matrix [[4,-2,-2],[2,4,-2],[-2,-2,4]]
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<cwith|1|-1|2|2|cell-halign|c>|<cwith|1|-1|3|3|cell-halign|c>|<table|<row|<cell|4>|<cell|-2>|<cell|-2>>|<row|<cell|2>|<cell|4>|<cell|-2>>|<row|<cell|-2>|<cell|-2>|<cell|4>>>>><right|]><leqno>(55)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      determinant(m1)
    </input>

    <\output>
      <with|mode|math|math-display|true|48<leqno>(56)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      m1^-1
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<cwith|1|-1|2|2|cell-halign|c>|<cwith|1|-1|3|3|cell-halign|c>|<table|<row|<cell|<frac|1|4>>|<cell|<frac|1|4>>|<cell|<frac|1|4>>>|<row|<cell|-<frac|1|12>>|<cell|<frac|1|4>>|<cell|<frac|1|12>>>|<row|<cell|<frac|1|12>>|<cell|<frac|1|4>>|<cell|<frac|5|12>>>>>><right|]><leqno>(57)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      characteristicPolynomial(m1, x)
    </input>

    <\output>
      <with|mode|math|math-display|true|-x<rsup|3>+12x<rsup|2>-44x+48<leqno>(58)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      solve(%=0,x)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[>x=6,<space|0.5spc>x=4,<space|0.5spc>x=2<right|]><leqno>(59)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      eigenvectors(m1)
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>e*i*g*v*a*l=2,<space|0.5spc>e*i*g*m*u*l*t=1,<space|0.5spc>e*i*g*v*e*c=<left|[><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|1>>|<row|<cell|0>>|<row|<cell|1>>>>><right|]><right|]><right|]>,<space|0.5spc><left|[>e*i*g*v*a*l=4,<space|0.5spc>e*i*g*m*u*l*t=1,<space|0.5spc>e*i*g*v*e*c=<left|[><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|1>>|<row|<cell|-1>>|<row|<cell|1>>>>><right|]><right|]><right|]>,<space|0.5spc><left|[>e*i*g*v*a*l=6,<space|0.5spc>e*i*g*m*u*l*t=1,<space|0.5spc>e*i*g*v*e*c=<left|[><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|0>>|<row|<cell|-1>>|<row|<cell|1>>>>><right|]><right|]><right|]><right|]><leqno>(60)>

      \;
    </output>

    3) Matrice de Vandermonde

    \ \ \ On vide les propriétés de x y z et t afin de réaliser le prochain
    exercice. Ainsi le type de matrice n'est pas erroné.

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )clear properties x y z t
    </input>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      mv := matrix [[1,x,x**2,x**3],[1,y,y**2,y**3],[1,z,z**2,z**3],[1,t,t**2,t**3]]
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<cwith|1|-1|2|2|cell-halign|c>|<cwith|1|-1|3|3|cell-halign|c>|<cwith|1|-1|4|4|cell-halign|c>|<table|<row|<cell|1>|<cell|x>|<cell|x<rsup|2>>|<cell|x<rsup|3>>>|<row|<cell|1>|<cell|y>|<cell|y<rsup|2>>|<cell|y<rsup|3>>>|<row|<cell|1>|<cell|z>|<cell|z<rsup|2>>|<cell|z<rsup|3>>>|<row|<cell|1>|<cell|t>|<cell|t<rsup|2>>|<cell|t<rsup|3>>>>>><right|]><leqno>(61)>
    </output>

    \ \ \ On remarque que lorsqu'une fonction ne possède qu'un argument, on
    n'est pas obligé de mettre cet argument entre parenthèses accolées à la
    fonction.\ 

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      determinant mv
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|(><left|(>-x+t<right|)>y<rsup|2>+<left|(>x<rsup|2>-t<rsup|2><right|)>y-t*x<rsup|2>+t<rsup|2>x<right|)>z<rsup|3>+<left|(><left|(>x-t<right|)>y<rsup|3>+<left|(>-x<rsup|3>+t<rsup|3><right|)>y+t*x<rsup|3>-t<rsup|3>x<right|)>z<rsup|2>+<left|(><left|(>-x<rsup|2>+t<rsup|2><right|)>y<rsup|3>+<left|(>x<rsup|3>-t<rsup|3><right|)>y<rsup|2>-t<rsup|2>x<rsup|3>+t<rsup|3>x<rsup|2><right|)>z+<left|(>t*x<rsup|2>-t<rsup|2>x<right|)>y<rsup|3>+<left|(>-t*x<rsup|3>+t<rsup|3>x<right|)>y<rsup|2>+<left|(>t<rsup|2>x<rsup|3>-t<rsup|3>x<rsup|2><right|)>y<leqno>(62)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      factor(%)
    </input>

    <\output>
      <with|mode|math|math-display|true|-<left|(>x-t<right|)><left|(>y-x<right|)><left|(>y-t<right|)><left|(>z-y<right|)><left|(>z-x<right|)><left|(>z-t<right|)><leqno>(63)>

      \;
    </output>
  </with>

  <page-break>

  \;

  <\with|par-mode|center>
    <subsection|Graphiques>
  </with>

  <\itemize-dot>
    <item> \ \ Partie Axiom : La partie traitée sera uniquement numérique. En
    effet, il semble qu'une implémentation graphique d'Axiom existe, mais
    elle nécessite la présence d'un \S viewport manager \T, composant
    introuvable malgré toutes les recherches effectuées. Les commandes de
    tracés sont effectuées via la fonction draw ( fonction, variables ).
    Après questionnement d'un développeur Axiom, il semblerait que cette
    fonction n'ai pas été importée lors du portage d'Axiom. Le viewport
    manager était intégré dans la version commerciale d'Axiom. Une
    implémentation future dans la version libre est à venir.

    \;
  </itemize-dot>

  <subsubsection|Courbes dans le plan>

  1) Représentations graphiques

  a) Définir la fonction f(x)=<with|mode|math|<frac|x<rsup|2>+4x-5|x+1>> et
  en construire la courbe représentative.

  b) Décomposer la fraction en éléments simples et tracer l'asymptote sur le
  même graphique.

  <with|prog-language|axiom|prog-session|default|<\session>
    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      F:=(x^2+4*x-5)/(x+1)
    </input>

    <\output>
      <with|mode|math|math-display|true|<frac|x<rsup|2>+4x-5|x+1><leqno>(64)>

      \;
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      partialFraction((x^2+4*x-5)::UP(x, FRAC INT),(x+1)::UP(x, FRAC INT))
    </input>

    <\output>
      <with|mode|math|math-display|true|x+3-<frac|8|x+1><leqno>(65)>

      \;
    </output>

    \;

    2) Soit G<with|mode|math|<rsub|n>> définie sur
    <strong|<name|<name|<name|<name|<name|<name|<name|<name|<name|R>>>>>>>>>>
    par G<with|mode|math|<rsub|n>>(y) = 1-e<with|mode|math|<rsup|-\<lambda\>
    y<rsup|n>>> si y <with|mode|math|\<geqslant\>> 0, 0 si y \<less\> 0 et sa
    dérivée g<with|mode|math|<rsub|n>(y).>

    \;

    a) Représenter graphiquement G<with|mode|math|<rsub|n> et g<rsub|n> pour
    plusieurs valeurs de n entier naturel positif.>

    \;

    \ \ \ Pour définir une fonction par morceaux, on fait appel aux fonctions
    de programmation d'Axiom, la fonction \S piecewise \T n'existant pas.

    \;

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      a(y) == if y \<less\> 0 then 0 else 1-exp(-y^n)
    </input>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      n:=2
    </input>

    <\output>
      <with|mode|math|math-display|true|2<leqno>(67)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      a(-3)
    </input>

    <\output>
      \ \ \ Compiling function a with type Integer -\<gtr\> Expression
      Integer\ 

      <with|mode|math|math-display|true|0<leqno>(68)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      a(5)
    </input>

    <\output>
      \ \ \ Compiling function a with type PositiveInteger -\<gtr\>
      Expression Integer

      \ \ \ \ \ \ 

      <with|mode|math|math-display|true|<frac|e<rsup|25>-1|e<rsup|25>><leqno>(69)>

      \;
    </output>

    3) On considère la fonction f définie par f(x) = x si \|x\| \<less\>1 et
    1/x sinon

    \;

    a) Définir f et tracer sa courbe représentative

    b) Étudier l'existence des intégrales généralisées suivantes\ 

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      f(x) == if abs(x) \<less\> 1 then 1 else 1/x<axiomtype|Void >
    </input>

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      f(0.5)
    </input>

    <\output>
      \ \ \ Compiling function f with type Float -\<gtr\> Float\ 

      <with|mode|math|math-display|true|1.0<leqno>(2)>

      \;
    </output>

    \ \ \ L'intégration de fonctions définies en programmation est
    impossible.

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      integrate(f(x), x=0..%plusInfinity)
    </input>

    <\output>
      \ 

      \ \ \ \<gtr\>\<gtr\> Error detected within library code:

      \ \ \ integrate: pole in path of integration

      protected-symbol-warn called with (NIL)

      \;
    </output>

    4) Définition des fonctions périodiques du polycopié:

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      h(x)==acos(cos(x))
    </input>

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      g(x)==atan(tan(x))
    </input>

    \;

    5 et 6: Les tracés étant impossibles à réaliser avec Axiom, cette partie
    sera traitée uniquement avec GNUplot.

    \;

    \;
  </session>>

  <\itemize-dot>
    <item> \ \ Partie GNUplot: La partie traitée sera uniquement numérique,
    GNUplot n'étant pas un logiciel de calcul formel, mais uniquement de
    tracé. On utilisera les résultats trouvés précédemment pour le tracé des
    courbes.\ 

    \;
  </itemize-dot>

  <with|prog-language|gnuplot|prog-session|default|<\session>
    \ \ \ La commande set sample 500 sert à modifier la précision du tracé.
    500 est un bon compromis entre rapidité d'exécution et qualité de tracé.
    On définit ensuite la fonction f(x), puis on trace sur le même graphique
    f(x), et x+3

    \;

    <\input|GNUplot] >
      set sample 500;f(x)=(x**2+4*x-5)/(x+1);plot f(x),x+3
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 45184 characters]>|ps>||||||>

      \;
    </output>

    On définit la fonction par morceaux de la façon qui suit :\ 

    fonction= test?résultat:test?résultat:...:dernier_cas

    \;

    <\input|GNUplot] >
      \ set sample 500;g(x) = 0\<gtr\>x ? 0 :1-exp(-2*x**n);n=3;plot g(x)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 36670 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set sample 500;f(x) = 1\<gtr\>abs(x) ? x : 1/x; plot f(x)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 39276 characters]>|ps>||||||>

      \;
    </output>

    On active le mode paramétrique par la commande set parametric. La
    variable par défaut est t.

    \;

    <\input|GNUplot] >
      set sample 500;set parametric;plot cos(3*t),sin(4*t)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 43114 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set parametric;set sample 500;plot sin(2*t),sin(3*t)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 42742 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set parametric;set sample 500;plot cos(t)+sin(t),sin(3*t)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 41086 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set parametric;set sample 500;plot sin(t),sin(3*t+pi/4)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 42338 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set parametric;set sample 500;plot cos(3*t-pi/6),sin(5*t+pi/4)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 43200 characters]>|ps>||||||>

      \;
    </output>

    On active le mode polaire. Par défaut la variable est t.

    \;

    <\input|GNUplot] >
      set polar;set sample 500;plot sin(3*t)/sin(t)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 40406 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set polar;set sample 500;plot (t-pi/4)/(t+pi/4)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 39838 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set polar;set sample 500;plot sin(t)/(1+2*cos(t))
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 36064 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set polar;set sample 500; plot 1+tan(t)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 39302 characters]>|ps>||||||>

      \;
    </output>

    <subsubsection|Surfaces dans l'espace>

    \;

    En mode paramétrique, les variables de surface sont u et v.

    \;

    <\input|GNUplot] >
      set sample 500;set parametric;splot u*cos(v),u*sin(v),u
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 182742 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set sample 500;splot [-10:10] [-10:10] x**2+y**2
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 165618 characters]>|ps>||||||>

      \;
    </output>

    <\input|GNUplot] >
      set sample 500;splot sqrt(x**2+y**2),-sqrt(x**2+y**2)
    </input>

    <\output>
      <postscript|<tuple|<#[encoded data, 292700 characters]>|ps>||||||>

      \;
    </output>

    \;
  </session>>

  <page-break>

  \;

  <\with|par-mode|center>
    <subsection|Programmation>
  </with>

  <\with|prog-language|axiom|prog-session|default>
    <subsubsection|Suites>

    1) Peut on faire confiance à la calculatrice ?

    Soit la suite (un)<with|mode|math|<rsub|n>> définie par
    u<with|mode|math|<rsub|0 >>= <with|mode|math|<frac|11|2>> ,
    u<with|mode|math|<rsub|1>=><with|mode|math|<frac|61|11>> ,
    u<with|mode|math|<rsub|n+1>>=111-<with|mode|math|<frac|1130|u<rsub|n>>>+<with|mode|math|<frac|3000|u<rsub|n>*.
    u<rsub|n-1>>>

    <\with|par-left|>
      a) Calculer les premiers termes. Quelle est la limite apparente ?

      \ \ \ Il est malheureusement impossible (ou du moins très peu pratique
      ) de taper directement les lignes de programmation dans Axiom. En
      effet, si l'on ne passe pas par l'intermédiaire d'un fichier texte, il
      est impossible de donner une indentation correcte au programme. On
      créera donc tout d'abord un fichier ( ici nommé exo1.input ) dont la
      structure est celle donnée ci-dessous, puis o chargera ce fichier dans
      Axiom par la commande )read . Un debbuger plus ou moins efficace se
      charge de détecter les erreurs. on commentera les lignes par des #,
      même si le commentaire n'est pas inclut dans Axiom.

      Contenu de exo1.input et structure générale des programmes à écrire
      dans un fichier texte.\ 
    </with>

    <\code>
      <with|color|red|<\with|par-hyphen|professional>
        p : Integer -\<gtr\> Float

        <with|color|black|# On défini une fonction p comme prenant un entier
        en parametre, et retournant un # réel.>

        p n ==

        <with|color|black|# On donne le nom du paramêtre: n >

        \ \ \ if n = 0 then

        <\with|color|black>
          \ \ \ \ \ \ \ \ \ # On remarque l'absence de end, et autres
          crochets. Cela est du au fait

          \ \ \ \ \ \ \ \ \ # qu'axiom fait attention à l'indentation pour
          définir les structures

          \ \ \ \ \ \ \ \ \ # imbriquées
        </with>

        \ \ \ \ \ \ \ \ <samp|> 11/2<samp|<samp|<samp|>>>

        \ \ \ \ \ \ \ \ \ <with|color|black|# On retourne 11/2>

        \ \ \ \ \ \ else

        \ \ \ \ \ \ \ \ \ if n = 1 then

        \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 61/11

        \ \ \ \ \ \ \ \ \ \ \ \ else

        \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 111- 1130/( p (n-1)) + 3000/( p (n-1) *
        p (n-2))
      </with>>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ # Un résultat seul sur une ligne signifie
      la fin du programme,\ 

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ # et le retour de la valeur par la
      fonction
    </code>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )read exo1.input
    </input>

    <\output>
      p : Integer -\<gtr\> Float

      \ 

      <axiomtype|Void >p n ==

      \ \ \ if n = 0 then

      \ \ \ \ \ \ \ \ \ 11/2

      \ \ \ \ \ \ else

      \ \ \ \ \ \ \ \ \ if n = 1 then

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 61/11

      \ \ \ \ \ \ \ \ \ \ \ \ else

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 111- 1130/( p (n-1)) + 3000/( p (n-1) * p
      (n-2))

      \ 
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      p 10
    </input>

    <\output>
      \ \ \ Compiling function p with type Integer -\<gtr\> Float\ 

      \ \ \ Compiling function p as a recurrence relation.

      <with|mode|math|math-display|true|5.86095152603794319<leqno>(76)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      p 15
    </input>

    <\output>
      <with|mode|math|math-display|true|5.94398604992555088<leqno>(77)>

      <axiomtype|Float >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      p 20
    </input>

    <\output>
      <with|mode|math|math-display|true|98.676371816945483885<leqno>(78)>

      <axiomtype|Float >
    </output>

    c ) Calculer, pour diverses valeurs de n,
    w<with|mode|math|<rsub|n>=><with|mode|math|<frac|6<rsup|n+1>+5<rsup|n+1>|6<rsup|n>+5<rsup|n>>>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      w(n) == (6^(n+1)+5^(n+1))/(6^n +5^n)
    </input>

    <\output>
      <axiomtype|Void >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      w(10)
    </input>

    <\output>
      \ \ \ Compiling function w with type PositiveInteger -\<gtr\> Fraction
      Integer\ 

      <with|mode|math|math-display|true|<frac|411625181|70231801><leqno>(80)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      w(10) :: Float\ 
    </input>

    <\output>
      <with|mode|math|math-display|true|5.8609515225161319728<leqno>(81)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      w(15) :: Float
    </input>

    <\output>
      <with|mode|math|math-display|true|5.9390504854611181512<leqno>(83)>
    </output>

    \ \ \ Remarque importante: Axiom fait des erreurs d'arrondi. On remarque
    une différence significative entre les valeurs des 2 fonctions en 15. On
    peut néanmoins assez facilement corriger cette erreur en modifiant le
    type retourné par la fonction en Fraction Integer au lieu de Float.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      w(100) :: Float
    </input>

    <\output>
      <with|mode|math|math-display|true|5.9999999879253266734<leqno>(82)>
    </output>

    2) Étude suivant a de la suite définie par
    u<with|mode|math|<rsub|0>>=<with|mode|math|<frac|1|2>>
    u<with|mode|math|<rsub|n>=4a u<rsub|n >(1-u<rsub|n>)>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )read exo2.input
    </input>

    <\output>
      u : Integer -\<gtr\> Float

      \ 

      <axiomtype|Void >u n ==

      \ \ \ a := 0.2

      \ \ \ if n = 0 then

      \ \ \ \ \ \ \ \ \ 1/2

      \ \ \ \ \ \ else

      \ \ \ \ \ \ \ \ \ 4*a*u (n-1)*(1 - u (n-1))
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      u(10)
    </input>

    <\output>
      \ \ \ Function definition for a is being overwritten.

      \ \ \ Compiling function u with type Integer -\<gtr\> Float\ 

      <with|mode|math|math-display|true|0.013634905645531645253<leqno>(85)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      u(1003)
    </input>

    <\output>
      \ 

      \ \ \ \<gtr\>\<gtr\> System error:

      \ \ \ Invocation history stack overflow.

      protected-symbol-warn called with (NIL)

      \;
    </output>

    \ \ \ u(1003) n'est pas calculé. Ceci est du à une protection de la
    mémoire, du programme. L'exécution est empêchée.

    \;

    <subsubsection|Sommes de séries>

    1) Soit la suite (u<with|mode|math|<rsub|n>)<rsub|n>> avec
    u<with|mode|math|<rsub|n>=<frac|1|n>>. On considère la série de terme
    général u<with|mode|math|<rsub|n>.>

    a) Calculer, pour différentes valeurs de n
    v<with|mode|math|<rsub|n>=<big|sum>u<rsub|k>>,
    w<with|mode|math|<rsub|n>>=<with|mode|math|<frac|v<rsub|n>|ln(n)>>,
    x<with|mode|math|<rsub|n >>=v<with|mode|math|<rsub|n>-ln(n)>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )read exo4.input
    </input>

    <\output>
      v : Integer -\<gtr\> Float

      \ 

      <axiomtype|Void >v n ==

      \ \ \ if n = 1 then

      \ \ \ \ \ \ \ \ \ \ 1

      \ \ \ \ \ \ else

      \ \ \ \ \ \ \ \ \ \ 1/n +v (n-1)

      \ 

      <axiomtype|Void >w : Integer -\<gtr\> Float

      \ 

      \ \ \ Compiled code for w has been cleared.

      <axiomtype|Void >w n ==

      \ \ \ \ \ v n/log(n)

      \ 

      \ \ \ 1 old definition(s) deleted for function or rule w\ 

      <axiomtype|Void >x : Integer -\<gtr\> Float

      \ 

      <axiomtype|Void >x n ==

      \ \ \ \ \ v n - log(n)

      \ 

      <axiomtype|Void >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      v 7
    </input>

    <\output>
      \ \ \ Compiling function v with type Integer -\<gtr\> Float\ 

      \ \ \ Compiling function v as a recurrence relation.

      <with|mode|math|math-display|true|2.5928571428571428572<leqno>(92)>

      <axiomtype|Float >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      w 3
    </input>

    <\output>
      \ \ \ Compiling function w with type Integer -\<gtr\> Float\ 

      <with|mode|math|math-display|true|1.6687719154825352216<leqno>(93)>

      <axiomtype|Float >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      x 13
    </input>

    <\output>
      \ \ \ Compiling function x with type Integer -\<gtr\> Float\ 

      <with|mode|math|math-display|true|0.6151843976722183977<leqno>(94)>

      <axiomtype|Float >
    </output>

    b) Déterminer la valeur de n<with|mode|math|<rsub|0>> telle que
    <with|mode|math|>pour n \<gtr\> n<with|mode|math|<rsub|0>>
    v<with|mode|math|<rsub|n> >\<gtr\> A pour A = 5,6,8 et 10. Faire un
    programme qui affiche les résultats intermédiaires, et un autre qui ne
    donne que n. Comparer les temps de calcul.

    \;

    \ \ \ Dans cet exercice, on met plusieurs fonctions les unes après les
    autres. Le système est exactement le même. On écrit simplement une
    fonction après l'autre.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )read exo5.input
    </input>

    <\output>
      calcul : Integer -\<gtr\> Float

      \ 

      <axiomtype|Void >calcul A ==

      \ \ n := 1

      \ \ while v n \<less\> A repeat

      \ \ \ \ n := n+1

      \ \ n

      \ 

      <axiomtype|Void >calculaff : Integer -\<gtr\> Float

      \ 

      <axiomtype|Void >calculaff A ==

      \ \ n := 1

      \ \ while v n \<less\> A repeat

      \ \ \ output(n) \ \ \ 

      \ \ \ n := n+1

      \ \ n
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )set messages time on
    </input>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      calcul 5
    </input>

    <\output>
      \ \ \ Compiling function calcul with type Integer -\<gtr\> Float\ 

      <with|mode|math|math-display|true|83.0<leqno>(99)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.01 (EV) + 0.06 (GC) = 0.07 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      calcul 6
    </input>

    <\output>
      <with|mode|math|math-display|true|227.0<leqno>(100)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.01 (EV) = 0.01 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      calcul 8
    </input>

    <\output>
      <with|mode|math|math-display|true|1674.0<leqno>(101)>

      <axiomtype|Float > \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.11 (EV) + 0.11 (GC) = 0.22 sec

      \;
    </output>

    \ \ \ Même calcul avec affichage intermédiaire en console: 0.35 secondes.
    en mode X : 2 secondes

    \ \ 

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      calcul 10
    </input>

    <\output>
      <with|mode|math|math-display|true|12367.0<leqno>(102)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.74 (EV) + 0.85 (GC) = 1.59 sec
    </output>

    \ \ \ Même calcul avec affichage intermédiaire en console : 2.5 sec. En
    mode X : plantage de TeXmacs

    2) Ordre des termes d'une série. Soit la série
    S1=<with|mode|math|<big|sum>><with|mode|math|<frac|(-1)<rsup|n>|n>>

    a) Vérifier la semi-convergence

    \ \ \ Cet exercice est impossible à réaliser. Comme vu précédemment, les
    fonctions sommes ne supportent pas les bornes infinies.

    b) On construit une nouvelle série S2. Chaque terme positif est suivi de
    2 termes négatifs. En calculer les sommes partielles d''ordre 30, 90,
    puis 300 et les comparer.

    \;

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )read exo6.input
    </input>

    <\output>
      S2 : Integer -\<gtr\> Fraction Integer

      \ 

      <axiomtype|Void > \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0 sec

      S2 n ==

      \ \ \ if n = 1 then\ 

      \ \ \ \ \ \ \ \ \ 1

      \ \ \ \ \ \ else

      \ \ \ \ \ \ \ \ \ if even?(n) = true then

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ -(1/(2*n-2)+1/(2*n))+S2 (n-1)

      \ \ \ \ \ \ \ \ \ \ \ \ else

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 1/n+S2 (n-1)

      \ 

      <axiomtype|Void > \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0 sec

      \;
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      S2 30
    </input>

    <\output>
      \ \ \ Compiling function S2 with type Integer -\<gtr\> Fraction Integer\ 

      <with|mode|math|math-display|true|<frac|225175759291|665454160800><leqno>(105)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.01 (OT) = 0.01 sec

      \;
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      S2 90 :: Float
    </input>

    <\output>
      <with|mode|math|math-display|true|0.34381124364859670606<leqno>(106)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.06 (GC) = 0.06 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      S2 300 :: Float
    </input>

    <\output>
      <with|mode|math|math-display|true|0.34574164582781233234<leqno>(107)>

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Time:
      0.02 (EV) = 0.02 sec
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )set messages time off
    </input>

    \;

    <subsubsection|Arithmétique>

    Faire afficher directement, ou dans un tableau, les n premiers nombres
    premiers, puis faire afficher uniquement le n-ième nombre premier.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )read exo7.input
    </input>

    <\output>
      prime : Integer -\<gtr\> Integer

      \ 

      <axiomtype|Void >prime n ==

      \ \ \ i := 0

      \ \ \ x := 0

      \ \ \ while not (i = n) repeat

      \ \ \ \ \ while not prime?(x) repeat

      \ \ \ \ \ \ \ \ x := x+1

      \ \ \ \ \ print(x)

      \ \ \ \ \ i := i+1

      \ \ \ \ \ x := x+1

      \ \ \ x := x-1

      \ \ \ x
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      prime 7
    </input>

    <\output>
      \ \ \ Function definition for x is being overwritten.

      \ \ \ Compiling function prime with type Integer -\<gtr\> Integer\ 

      \ \ \ 2

      \ \ \ 3

      \ \ \ 5

      \ \ \ 7

      \ \ \ 11

      \ \ \ 13

      \ \ \ 17

      <with|mode|math|math-display|true|17<leqno>(110)>

      <axiomtype|PositiveInteger >
    </output>

    <subsubsection|Algèbre>

    \ \ \ Construire une matrice carrée n*n tel que chaque élément de la
    matrice soit égal à la somme du numéro de ligne et de colonne. Indiquer
    si la matrice est diagonalisable, en donner les valeurs propres et les
    vecteurs propres.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )read exo8.input
    </input>

    <\output>
      mat : Integer -\<gtr\> Matrix Integer

      \ 

      <axiomtype|Void >mat n ==

      \ \ \ matri := createGenericMatrix(n)

      \ \ \ for i in 1..(n::INT) repeat

      \ \ \ \ \ \ for j in 1..(n::INT) repeat

      \ \ \ \ \ \ \ \ \ matri(i,j) := i+j-1

      \ \ \ matri
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      mat 5
    </input>

    <\output>
      \ \ \ Your expression cannot be fully compiled because it contains an\ 

      \ \ \ \ \ \ integer expression (for n ) whose sign cannot be determined
      (in\ 

      \ \ \ \ \ \ general) and so must be specified by you. Perhaps you can
      try\ 

      \ \ \ \ \ \ substituting something like

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ (n
      :: PI)\ 

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ or

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ (n ::
      NNI)\ 

      \ \ \ \ \ \ into your expression for n .

      \ \ \ AXIOM will attempt to step through and interpret the code.

      \ \ \ Compiling function mat with type Integer -\<gtr\> Matrix Integer\ 

      \ \ \ Compiling function G1888 with type Integer -\<gtr\> Boolean\ 

      <with|mode|math|math-display|true|<left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<cwith|1|-1|2|2|cell-halign|c>|<cwith|1|-1|3|3|cell-halign|c>|<cwith|1|-1|4|4|cell-halign|c>|<cwith|1|-1|5|5|cell-halign|c>|<table|<row|<cell|1>|<cell|2>|<cell|3>|<cell|4>|<cell|5>>|<row|<cell|2>|<cell|3>|<cell|4>|<cell|5>|<cell|6>>|<row|<cell|3>|<cell|4>|<cell|5>|<cell|6>|<cell|7>>|<row|<cell|4>|<cell|5>|<cell|6>|<cell|7>|<cell|8>>|<row|<cell|5>|<cell|6>|<cell|7>|<cell|8>|<cell|9>>>>><right|]><leqno>(113)>

      <axiomtype|Matrix Integer >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      determinant( mat 6 )
    </input>

    <\output>
      <with|mode|math|math-display|true|0<leqno>(114)>
    </output>

    Détermination des vecteurs, et des valeurs propres.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      eigenvectors( mat 6 )
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><left|[>e*i*g*v*a*l=0,<space|0.5spc>e*i*g*m*u*l*t=4,<space|0.5spc>e*i*g*v*e*c=<left|[><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|1>>|<row|<cell|-2>>|<row|<cell|1>>|<row|<cell|0>>|<row|<cell|0>>|<row|<cell|0>>>>><right|]>,<space|0.5spc><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|2>>|<row|<cell|-3>>|<row|<cell|0>>|<row|<cell|1>>|<row|<cell|0>>|<row|<cell|0>>>>><right|]>,<space|0.5spc><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|3>>|<row|<cell|-4>>|<row|<cell|0>>|<row|<cell|0>>|<row|<cell|1>>|<row|<cell|0>>>>><right|]>,<space|0.5spc><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|4>>|<row|<cell|-5>>|<row|<cell|0>>|<row|<cell|0>>|<row|<cell|0>>|<row|<cell|1>>>>><right|]><right|]><right|]>,<space|0.5spc><left|[>e*i*g*v*a*l=<left|(>%O\<mid\>%O<rsup|2>-36%O-105<right|)>,<space|0.5spc>e*i*g*m*u*l*t=1,<space|0.5spc>e*i*g*v*e*c=<left|[><left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<table|<row|<cell|<frac|%O-29|22>>>|<row|<cell|<frac|2%O-47|55>>>|<row|<cell|<frac|3%O-43|110>>>|<row|<cell|<frac|%O+4|55>>>|<row|<cell|<frac|%O+59|110>>>|<row|<cell|1>>>>><right|]><right|]><right|]><right|]><leqno>(115)>

      Type: List Record(eigval: Union(Fraction Polynomial
      Integer,SuchThat(Symbol,Polynomial Integer)),eigmult:
      NonNegativeInteger,eigvec: List Matrix Fraction Polynomial Integer)

      \;
    </output>

    <subsubsection|Procédures>

    1) Générer un triangle de pascal

    \ \ \ Le programme génère des erreurs inhabituelles de \S conversion \T.
    La compilation effective du programme est impossible. On utilisera une
    version non compilée.

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      l :=12
    </input>

    <\output>
      <with|mode|math|math-display|true|12<leqno>(116)>
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      matripas := createGenericMatrix((l::PI));matripas(1,1) :=
      1;matripas(2,1) := 1;matripas(2,2) := 1;for i in 3..(l::PI) repeat
      {matripas(i,i) := 1,matripas(i,1) := 1,for j in 2..((i::PI)-1) repeat
      matripas(i,j) := matripas(( i - 1 ),j) + matripas(( i - 1),( j - 1
      ))};matripas
    </input>

    <\output>
      <with|mode|math|math-display|true|<left|[><tabular*|<tformat|<cwith|1|-1|1|1|cell-halign|c>|<cwith|1|-1|2|2|cell-halign|c>|<cwith|1|-1|3|3|cell-halign|c>|<cwith|1|-1|4|4|cell-halign|c>|<cwith|1|-1|5|5|cell-halign|c>|<cwith|1|-1|6|6|cell-halign|c>|<cwith|1|-1|7|7|cell-halign|c>|<cwith|1|-1|8|8|cell-halign|c>|<cwith|1|-1|9|9|cell-halign|c>|<cwith|1|-1|10|10|cell-halign|c>|<cwith|1|-1|11|11|cell-halign|c>|<cwith|1|-1|12|12|cell-halign|c>|<table|<row|<cell|1>|<cell|x<rsub|1,<space|0.5spc>2>>|<cell|x<rsub|1,<space|0.5spc>3>>|<cell|x<rsub|1,<space|0.5spc>4>>|<cell|x<rsub|1,<space|0.5spc>5>>|<cell|x<rsub|1,<space|0.5spc>6>>|<cell|x<rsub|1,<space|0.5spc>7>>|<cell|x<rsub|1,<space|0.5spc>8>>|<cell|x<rsub|1,<space|0.5spc>9>>|<cell|x<rsub|1,<space|0.5spc>10>>|<cell|x<rsub|1,<space|0.5spc>11>>|<cell|x<rsub|1,<space|0.5spc>12>>>|<row|<cell|1>|<cell|1>|<cell|x<rsub|2,<space|0.5spc>3>>|<cell|x<rsub|2,<space|0.5spc>4>>|<cell|x<rsub|2,<space|0.5spc>5>>|<cell|x<rsub|2,<space|0.5spc>6>>|<cell|x<rsub|2,<space|0.5spc>7>>|<cell|x<rsub|2,<space|0.5spc>8>>|<cell|x<rsub|2,<space|0.5spc>9>>|<cell|x<rsub|2,<space|0.5spc>10>>|<cell|x<rsub|2,<space|0.5spc>11>>|<cell|x<rsub|2,<space|0.5spc>12>>>|<row|<cell|1>|<cell|2>|<cell|1>|<cell|x<rsub|3,<space|0.5spc>4>>|<cell|x<rsub|3,<space|0.5spc>5>>|<cell|x<rsub|3,<space|0.5spc>6>>|<cell|x<rsub|3,<space|0.5spc>7>>|<cell|x<rsub|3,<space|0.5spc>8>>|<cell|x<rsub|3,<space|0.5spc>9>>|<cell|x<rsub|3,<space|0.5spc>10>>|<cell|x<rsub|3,<space|0.5spc>11>>|<cell|x<rsub|3,<space|0.5spc>12>>>|<row|<cell|1>|<cell|3>|<cell|3>|<cell|1>|<cell|x<rsub|4,<space|0.5spc>5>>|<cell|x<rsub|4,<space|0.5spc>6>>|<cell|x<rsub|4,<space|0.5spc>7>>|<cell|x<rsub|4,<space|0.5spc>8>>|<cell|x<rsub|4,<space|0.5spc>9>>|<cell|x<rsub|4,<space|0.5spc>10>>|<cell|x<rsub|4,<space|0.5spc>11>>|<cell|x<rsub|4,<space|0.5spc>12>>>|<row|<cell|1>|<cell|4>|<cell|6>|<cell|4>|<cell|1>|<cell|x<rsub|5,<space|0.5spc>6>>|<cell|x<rsub|5,<space|0.5spc>7>>|<cell|x<rsub|5,<space|0.5spc>8>>|<cell|x<rsub|5,<space|0.5spc>9>>|<cell|x<rsub|5,<space|0.5spc>10>>|<cell|x<rsub|5,<space|0.5spc>11>>|<cell|x<rsub|5,<space|0.5spc>12>>>|<row|<cell|1>|<cell|5>|<cell|10>|<cell|10>|<cell|5>|<cell|1>|<cell|x<rsub|6,<space|0.5spc>7>>|<cell|x<rsub|6,<space|0.5spc>8>>|<cell|x<rsub|6,<space|0.5spc>9>>|<cell|x<rsub|6,<space|0.5spc>10>>|<cell|x<rsub|6,<space|0.5spc>11>>|<cell|x<rsub|6,<space|0.5spc>12>>>|<row|<cell|1>|<cell|6>|<cell|15>|<cell|20>|<cell|15>|<cell|6>|<cell|1>|<cell|x<rsub|7,<space|0.5spc>8>>|<cell|x<rsub|7,<space|0.5spc>9>>|<cell|x<rsub|7,<space|0.5spc>10>>|<cell|x<rsub|7,<space|0.5spc>11>>|<cell|x<rsub|7,<space|0.5spc>12>>>|<row|<cell|1>|<cell|7>|<cell|21>|<cell|35>|<cell|35>|<cell|21>|<cell|7>|<cell|1>|<cell|x<rsub|8,<space|0.5spc>9>>|<cell|x<rsub|8,<space|0.5spc>10>>|<cell|x<rsub|8,<space|0.5spc>11>>|<cell|x<rsub|8,<space|0.5spc>12>>>|<row|<cell|1>|<cell|8>|<cell|28>|<cell|56>|<cell|70>|<cell|56>|<cell|28>|<cell|8>|<cell|1>|<cell|x<rsub|9,<space|0.5spc>10>>|<cell|x<rsub|9,<space|0.5spc>11>>|<cell|x<rsub|9,<space|0.5spc>12>>>|<row|<cell|1>|<cell|9>|<cell|36>|<cell|84>|<cell|126>|<cell|126>|<cell|84>|<cell|36>|<cell|9>|<cell|1>|<cell|x<rsub|10,<space|0.5spc>11>>|<cell|x<rsub|10,<space|0.5spc>12>>>|<row|<cell|1>|<cell|10>|<cell|45>|<cell|120>|<cell|210>|<cell|252>|<cell|210>|<cell|120>|<cell|45>|<cell|10>|<cell|1>|<cell|x<rsub|11,<space|0.5spc>12>>>|<row|<cell|1>|<cell|11>|<cell|55>|<cell|165>|<cell|330>|<cell|462>|<cell|462>|<cell|330>|<cell|165>|<cell|55>|<cell|11>|<cell|1>>>>><right|]><leqno>(118)>

      <axiomtype|Matrix Polynomial Integer >
    </output>

    <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
      )clear properties x
    </input>

    <\output>
      \ \ \ Compiled code for x has been cleared.

      \;
    </output>

    \;
  </with>

  \ \ \ Les 2 derniers exemples ne sont réalisables ni avec Axiom ( pas de
  visualisation graphique) ni avec GNUplot ( impossibilité de définir la
  courbe )

  \;

  \;

  <page-break>

  \;

  <\with|par-mode|center>
    <subsection|Calculs du programme MT26>
  </with>

  \ \ \ Les exercices ici réalisés sont des exercices \S en trop \T, réalisés
  afin de pouvoir visualiser d'autres exemples, en vue d'une éventuelle
  modification du polycopié. Ces calculs étaient demandés dans un polycopié
  précédent. On laissera ici l'affichage des types, afin de découvrir
  l'influence des paramètres sur la modification des types.

  <\with|prog-language|axiom|prog-session|default>
    <\session>
      <\input|>
        \;
      </input>

      <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
        integrate((log(x)/((x-1)*sqrt(x*(1-x)))),x=0..1)
      </input>

      <\output>
        <with|mode|math|math-display|true|p*o*t*e*n*t*i*a*l*P*o*l*e<leqno>(119)>

        \;
      </output>

      Quand l'intégration est impossible, avec une erreur en potentialPole,
      il suffit de rajouter l'option \S noPole \T en dernier argument de la
      fonction d'intégration.

      \;

      <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
        integrate((log(x)/((x-1)*sqrt(x*(1-x)))),x=0..1, "noPole")
      </input>

      <\output>
        <with|mode|math|math-display|true|2\<pi\><leqno>(120)>
      </output>

      <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
        integrate(log(x)/sqrt(x),x=0..1/2)
      </input>

      <\output>
        <with|mode|math|math-display|true|p*o*t*e*n*t*i*a*l*P*o*l*e<leqno>(121)>

        <axiomtype|Union(pole: potentialPole,...) >
      </output>

      <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
        integrate(log(x)/sqrt(x),x=0..1/2, "noPole")
      </input>

      <\output>
        <with|mode|math|math-display|true|<frac|-log
        <left|(>4<right|)>-4|<sqrt|2>><leqno>(122)>

        <axiomtype|Union(f1: OrderedCompletion Expression Integer,...) >
      </output>

      \;

      <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
        g(x) == integrate(t^(x-1)*exp(-t),t= 1..%plusInfinity, "noPole")

        <axiomtype|Union(pole: potentialPole,...) >
      </input>

      <\output>
        \ \ \ 1 old definition(s) deleted for function or rule g\ 

        <axiomtype|Void >
      </output>

      <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
        g(3)
      </input>

      <\output>
        \ \ \ Compiling function g with type PositiveInteger -\<gtr\>
        Union(f1:\ 

        \ \ \ \ \ \ OrderedCompletion Expression Integer,f2: List
        OrderedCompletion\ 

        \ \ \ \ \ \ Expression Integer,fail: failed,pole: potentialPole)\ 

        <with|mode|math|math-display|true|<frac|5|e><leqno>(124)>

        <axiomtype|Union(f1: OrderedCompletion Expression Integer,...) >
      </output>

      <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
        g(7.5)
      </input>

      <\output>
        \ \ \ Compiling function g with type Float -\<gtr\>
        Union(Result,"failed")\ 

        <with|mode|math|math-display|true|<with|mode|text|font-family|tt|"failed"><leqno>(125)>

        <axiomtype|Union("failed",...) >
      </output>

      <\input|<with|color|red|<with|mode|math|\<rightarrow\>> >>
        g(8)
      </input>

      <\output>
        <with|mode|math|math-display|true|<frac|13700|e><leqno>(126)>

        <axiomtype|Union(f1: OrderedCompletion Expression Integer,...) >
      </output>

      \ 
    </session>
  </with>

  <with|font-size|1.19|<with|font-series|bold|<\with|par-mode|center>
    Fin de la résolution des exercices
  </with>>>

  <page-break>

  \;

  \;

  <\with|par-mode|center>
    <section|Conclusion >
  </with>

  \;

  \;

  \ \ \ Grâce à ces exercices, et à leur résolution, on peut se faire une
  idée précise quand à l'application et à l'utilisation des logiciels Axiom
  et GNUplot en TD de MT26.\ 

  \ \ \ Étudions le cas de GNUplot : Celui-ci, est certes très simple
  d'emploi et est fourni avec une documentation détaillée, mais se révèle
  malheureusement bien trop incomplet, et ne satisfera que 10% environ des
  questions du TP d'MT26. Son champ d'application est beaucoup trop restreint
  par rapport à la demande faite, et de ce fait, est inutilisable en tant que
  logiciel de calcul formel. Néanmoins, une utilisation en TP de physique est
  tout à fait envisageable, pour le tracé de nuage de points, de comparaison
  avec une courbe, etc.. L'avantage qu'il présente face à un logiciel comme
  Excel, est, mis à part sa gratuité, sa capacité à faire évoluer le
  graphique en temps réel (rotations, zooms, etc..).\ 

  \ \ \ Dans le cas d'Axiom, il est nécessaire de faire la part des choses :
  La mentalité, le système d'aide, et les ressources disponibles creusent
  certes un écart important avec Maple, mais cette différence s'avère surtout
  déroutante au début, pendant la prise en main du logiciel: Les fonctions et
  la rapidité d'exécution de celui-ci en font un concurrent sérieux pour
  Maple. Néanmoins, Axiom n'est pas prêt, pour l'instant, à devenir un
  logiciel d'enseignement pédagogique. Cette opinion sera sans doute à revoir
  d'ici quelques semestres mais les résolutions d'exercices se font à l'heure
  actuelle bien souvent par tâtonnements: La spécificité des types empêche
  une résolution logique de certains exercices (en particulier pour la
  décomposition en éléments simples, vrai casse-tête, ou la compilation
  impossible de certains calculs sans raisons apparentes) Les efforts fait
  pour améliorer l'interface, développer l'intuitivité des fonctions, et
  ajouter les éléments manquants vont pourtant permettre d'ici peu une
  utilisation pratique de ce logiciel, même à un niveau éducatif. Dès le
  portage du ViewPort Manager, Axiom sera une alternative possible à Maple.
  Dans tous les cas, l'utilisation d'Axiom se fera obligatoirement à travers
  une interface TeXmacs, le mode console étant beaucoup trop déroutant pour
  un non-initié à Linux.\ 

  \ \ \ Cette étude complète nous aura donc permis de nous former à une
  certaine méthodologie de travail, la documentation étant à l'heure actuelle
  assez faible, en ce qui concerne axiom. De plus nous nous sommes habitués
  au fonctionnement de TeXmacs, à l'utilisation de structures bien définies,
  à un environnement totalement nouveau. Cette UV a été particulièrement
  formatrice en ce qui concerne la pratique de l'informatique avec des
  logiciels libres.

  \ \ \ \ 

  <page-break>

  <\with|par-mode|center>
    <section|Annexes>
  </with>

  \;

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|License
    pour Documents Libres>>>>>>
  </cell>>>>>

  <next-line>Version 1.0<next-line>Copyright ( 2000 Guilde des
  Doctorants.<next-line><next-line><label|toc11>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|1>>|<cell|<with|font-series|bold|Introduction>>>>>>
  </cell>>>>>

  <next-line>Le but de cette license, rédigée par la Guilde des Doctorants,
  est de rendre <em|libres> les documents écrits auquels elle s'applique. Un
  document est dit <em|libre> au sens ou chacun peut le recopier et le
  distribuer, avec ou sans modification par tous moyens possibles et
  imaginables. Cette license préserve la propriété intellectuelle de l'auteur
  et de l'éditeur du document. Elle est aussi concue pour éviter toute
  récupération commerciale d'un travail bénévole sans le consentement express
  de ses auteurs. D'autres licences rendant libres des documents, des
  contenus, des publications existent comme la Free Documentation License de
  la Free Software Fundation<hlink|<label|text2><rsup|1>|#note2> et
  l'initiative OpenContent<hlink|<label|text3><rsup|2>|#note3>. Elles sont en
  rédigées en langue anglaise et font parfois référence à des notions de
  droit américain (notion de <em|fair use>). Nous avons très largement repris
  certains des points de ces licenses et nous en avons laissé certains de
  coté. Néanmoins ces licenses comme la LDL partagent une même vocation. La
  Licence pour Documents Libres (LDL), rédigée en français est sujette à
  améliorations qui sont les bienvenues (voir section
  <hlink|7|#secFin>).<next-line><next-line><next-line><next-line><next-line>Cette
  license a été conçue pour s'appliquer à divers types de documents quel que
  soit leur support : documents techniques, notes de cours, documentation
  logicielle ou encore oeuvres de fictions. Elle inclut également un
  "copyleft" pour reprendre la terminologie du GNU : tous les documents
  dérivés du document original héritent de cette
  license.<next-line><next-line><label|toc12>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|2>>|<cell|<with|font-series|bold|Définitions
    et domaine d'application>>>>>>
  </cell>>>>>

  <label|secDefinitions><next-line>Cette license s'applique à tout document,
  quelle que soit sa forme, comprenant la notice standard associée à cette
  license. La "notification de license" désigne la section du texte où sont
  mentionnés le fait que le document est soumis à la présente license ainsi
  que le copyright du document.<next-line><next-line>Un document est produit
  par un ou plusieurs <em|auteurs>. Un document peut être constitué de
  plusieurs contributions mises en commun. Dans ce cas, l'<em|éditeur>
  désigne la personne morale ou physique qui assure la mise à disposition du
  document sous diverses formes. S'il n'y a qu'un auteur, il est son propre
  éditeur. Conformément au code de la propriété intellectuelle, chaque auteur
  conserve la propriété intellectuelle sur sa contribution. Toutefois,
  l'éditeur a toute liberté pour faire évoluer le document dans le respect
  des dispositions de la présente license.<next-line><next-line>La notice de
  copyright mentionne l'éditeur si il existe ainsi que les noms des
  auteurs.<next-line><next-line><next-line><next-line><next-line>On appellera
  "<em|version dérivée>" tout document comprenant le document de départ
  partiellement ou dans son intégralité. Une traduction est aussi considérée
  comme une version dérivée.<next-line><next-line><next-line><next-line><next-line>La
  "<em|section historique>" du document désigne une partie du document
  comprenant un historique de sa genèse et de son évolution. Dans le cas d'un
  document derivé, la section historique contient le descriptif du ou des
  documents originaux et des modifications qui y ont été apportées. Elle peut
  également contenir des éléments non factuels comme des considérations
  éthiques ou politiques concernant l'historique et les motivations du
  document. La section historique peut donc n'avoir aucun rapport avec
  l'objet principal du document.<next-line><next-line><next-line><next-line><next-line>La
  "<em|Page de titre>" désigne pour un document imprimé la page de titre au
  sens usuel plus les pages de couvertures. Dans le cas de documents pour
  lesquels ces notions de s'appliquent pas, c'est le texte proche de
  l'endroit où apparaît le titre du document et la fin du document. La
  notification de license sera placée dans la page de titre. La notice
  standard minimale aura la forme suivante :<next-line><next-line>

  <\quotation>
    "Copyright (c) ANNEE, EDITEUR et AUTEURS. Le contenu de ce document peut
    être redistribué sous les conditions énoncées dans la License pour
    Documents Libres version x.y ou utlérieure."
  </quotation>

  Un document peut contenir des "<em|sections invariantes>". La liste des
  titres de sections invariantes est précisée dans la notice spécifiant que
  le document est soumis à la présente license. Par exemple
  :<next-line><next-line>

  <\quotation>
    "Le présent document contient un certain nombre de sections invariantes
    qui devront figurer sans modification dans toutes les modifications qui
    seront apportées au document. Leur titres sont: TITRES DES SECTIONS
    INVARIANTES".
  </quotation>

  Nous distinguons trois modes de diffusion de documents
  électroniques:<next-line><next-line>

  <\itemize>
    <item>une forme "<em|transparente>", ce qui désigne tout format
    électronique dont les spécifications sont disponibles dans le domaine
    public ou qui peut être édité par des programmes éventuellement
    commerciaux largement disponibles à la date de publication du
    document.<next-line><next-line><next-line><next-line><next-line>Exemples:
    ASCII, Texinfo, TeX et LaTeX, RTF, HTML, XML, SGML avec une DTD
    publique.<next-line><next-line>

    <item>une forme "<em|opaque>", ce qui désigne tout format électronique
    permettant l'affichage ou l'impression du document de manière simple au
    moyen de logiciels du domaine public ou du moins très largement
    disponibles à la date de publication du document. Un tel format ne permet
    pas la modification dudit document de manière
    simple.<next-line><next-line><next-line><next-line><next-line>Exemples:
    Postscript, PDF, tout format de traitement de texte nécessitant un
    logiciel propriétaire, ou tout déclinaison de SGML dont la DTD n'est pas
    publique.<next-line><next-line>

    <item>une forme "<em|cryptée>" ce qui désigne le cas où une partie (ou la
    totalité) du document est sous un format électronique qui n'est pas
    lisible sans la possession d'une clef logicielle ou matérielle qui en
    permet le décodage. La <em|forme cryptée> peut être utilisée à des fins
    d'authentification. Une fois décodé le document peut être sous une forme
    transparente ou opaque.<next-line><next-line>Dans le cas d'une forme
    cryptée, si l'éditeur n'est plus en mesure de fournir la clef de
    décodage, il doit rendre disponible le document sous une forme
    transparente ou opaque non cryptée.
  </itemize>

  <label|toc13>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|3>>|<cell|<with|font-series|bold|Conditions
    communes aux versions modifiées et intégrales>>>>>>
  </cell>>>>>

  <label|secCommon><next-line>La distribution de versions intégrales et
  modifiées du présent document sous n'importe quelle forme est autorisée aux
  conditions suivantes :<next-line><next-line>

  <\itemize>
    <item>Les notices de copyright spécifiant que le document est soumis à la
    présente license ainsi que les sections invariantes doivent être
    préservées.<next-line><next-line>

    <item>Les sections invariantes ne peuvent être
    altérées.<next-line><next-line>

    <item>Les sections historiques ne peuvent être que
    complétées.<next-line><next-line>

    <item>La localisation<hlink|<label|text4><rsup|3>|#note4> du document
    original doit être mentionnée dans la page de titre et de manière
    visible.<next-line><next-line>

    <item>Un document disponible sous forme transparente ne peut être
    rediffusé sous forme opaque.<next-line><next-line>

    <item>Vous ne devez mettre en place aucun dispositif visant à restreindre
    l'accès au document ou la possibilité de reproduire les copies que vous
    distribuez. En particulier vous ne pouvez rendre disponible tout ou
    partie du document sous forme cryptée si l'auteur l'a expressément
    interdit.<next-line><next-line>

    <item>La redistribution dans un cadre commercial ne peut être effectuée
    sans l'accord préalable des auteurs et de l'éditeur du document
    original.<next-line><next-line>

    <item>Si la distribution de copies du document entraîne des frais de
    reproduction (photocopies, impressions, pressage de médias), vous pouvez
    néanmoins les imputer au lecteur. Mais vous ne pouvez pas percevoir de
    droits d'exploitation liés au contenu, ni à l'utilisation du document.
  </itemize>

  Si vous effectuez une diffusion en nombre du document (diffusion sur le
  WEB, par FTP, ou à plus de 99 exemplaires imprimés, par courrier
  électronique, sur CDROM, ou sur d'autres supports magnétiques ou optiques),
  vous devez inclure une copie de la présente license. Dans ce cas, vous
  devez également prévenir les éditeurs du document original afin de définir
  avec eux comment veiller à la diffusion de versions à jour du
  document.<next-line><next-line><label|toc14>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|4>>|<cell|<with|font-series|bold|Modifications>>>>>>
  </cell>>>>>

  <label|secModifs><next-line>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|4.1>>|<cell|<with|font-series|bold|Dispositions
    générales>>>>>>
  </cell>>>>>

  <label|secModifsGenerales><next-line>Vous pouvez utiliser une partie du
  présent document, en la modifiant éventuellement, pour produire un nouveau
  document. Les dispositions de la section <hlink|3|#secCommon>
  s'appliquent.<next-line><next-line><next-line><next-line><next-line>Vous
  devez en plus :<next-line><next-line>

  <\itemize>
    <item>lister un ou plusieurs auteurs ou entités responsables des
    modifications apportées au document.<next-line><next-line>

    <item>mentionner sur la page de titre que le document dérivé est une
    modification d'un ou plusieurs documents originaux. Vous devez préciser
    leurs titres ainsi que l'entité éditrice ou les principaux
    auteurs.<next-line><next-line>

    <item>préciser sur la page de titre que vous êtes l'éditeur de la version
    dérivée.
  </itemize>

  Vous ne devez en aucun cas :<next-line><next-line>

  <\itemize>
    <item>altérer une mention d'un nom d'auteur présent dans le document
    original et concernant une partie que vous avez
    réutilisé.<next-line><next-line>

    <item>donner au document dérivé le même titre que le document original
    sans autorisation de l'éditeur de celui-ci.
  </itemize>

  Nous recommandons de plus que les titres de sections ne soient altérés
  qu'en cas de changement du plan du document rendues nécessaire par les
  modifications apportées.<next-line><next-line>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|4.2>>|<cell|<with|font-series|bold|Fusion
    ou combinaisons de documents>>>>>>
  </cell>>>>>

  <label|secFusion><next-line>Dans le cas ou le document que vous produisez
  est issu de la combinaison de plusieurs documents (après modifications
  éventuelles) soumis eux aussi à la présente license, vous pouvez remplacer
  les diverses notifications de license par une
  seule.<next-line><next-line><next-line><next-line><next-line>De même, vous
  pouvez regrouper les diverses sections historiques pour n'en faire qu'une
  seule. Elle doit mentionner explicitement les documents originaux auxquels
  vous avez fait appel et indiquer leur localisation.<next-line><next-line><next-line><next-line><next-line>Si
  un des documents utilisé est disponible sous une forme transparente alors
  la totalité du document dérivé doit aussi
  l'être.<next-line><next-line><next-line><next-line><next-line>Vous devez
  respecter les points listés en sections <hlink|3|#secCommon> et
  <hlink|4.1|#secModifsGenerales>.<next-line><next-line>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|4.3>>|<cell|<with|font-series|bold|Inclusion
    dans d'autres travaux>>>>>>
  </cell>>>>>

  <label|secIncludes><next-line>Si le Document où une de ses versions
  dérivées est agrégé avec des travaux indépendants, de sorte que plus de 50
  % du document final ainsi produit ne soit pas soumis à la présente license,
  le document final n'est pas considéré comme une version dérivée sousmise
  dans son ensemble à la présente license. Néanmoins, la ou les portions du
  document final qui sont issues d'un document soumis à la présente license
  restent soumis à cette license. Les recommandations des sections
  <hlink|3|#secCommon> et <hlink|4|#secModifs>
  s'appliquent.<next-line><next-line><new-page>

  \;

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|4.4>>|<cell|<with|font-series|bold|Traduction>>>>>>
  </cell>>>>>

  <label|secTraduction><next-line>Une traduction d'un document est considérée
  comme une version dérivée. Dans ce cas, vous pouvez néanmoins traduire les
  sections invariantes. Si vous ne laissez pas les versions originales de ces
  sections, vous devez prendre contact avec l'éditeur de la version originale
  afin d'obtenir son accord pour les traductions de ces
  sections.<next-line><next-line><next-line><next-line><next-line>La Guilde
  proposera un certain nombre de traductions de cette license. Si il en
  existe une pour la langue cible de la traduction du document, c'est
  celle-ci qui s'applique. Dans le cas contraire vous ètes invité à proposer
  une traduction de la license à la Guilde. Si vous ne le faites pas, ou si
  la Guilde refuse cette traduction, c'est la version originale qui
  s'applique.<next-line><next-line><label|toc15>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|5>>|<cell|<with|font-series|bold|Dispositions
    concernant la garantie>>>>>>
  </cell>>>>>

  <next-line>Cette license ne définit que les droits de reproduction
  modification et diffusion du document. Elle n'y associe aucune garantie :
  sauf mention expresse du contraire, qui n'engagerait alors que l'éditeur du
  document, et dans la mesure où le contenu est en conformité avec la
  législation française, il est entendu que ni l'éditeur ni les auteurs du
  document ne sauraient être tenus pour responsables des éventuels dommages
  et préjudices que l'utilisation du document aurait entraîné. Ces
  dispositions s'appliquent même si il s'avère que le document contient
  naturellement ou par obsolescence une inexactitude, une imprécision ou une
  ambiguïté.<next-line><next-line><next-line><next-line><next-line>Tout
  auteur ou éditeur souhaitant doter un document soumis à la présente license
  de dispositions de garantie doit joindre à chaque copie distribuée du
  document un certificat de garantie précisant exactement les dispositions de
  garantie et mentionnant explicitement les noms des personnes morales ou
  physique assumant les responsabilités de la
  garantie.<next-line><next-line>Les dispositions de libre copie de la
  présente license restent valable pour un document avec garantie mais toute
  rediffusion par une autre personne que l'auteur du certificat de garantie
  se fait sans garantie.<next-line><next-line><label|toc16>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|6>>|<cell|<with|font-series|bold|Cessation
    de la license>>>>>>
  </cell>>>>>

  <next-line>Vous ne pouvez redistribuer le présent document ou une de ses
  versions dérivées sous une license différente. Cela entrainerait
  l'annulation des droits de copie, modification et distribution du
  document.<next-line><next-line><next-line><next-line><next-line>En
  soumettant un document à la présente license, vous conservez les droits de
  propriété intellectuelle liés à votre qualité d'auteur et vous acceptez que
  les droits de reproduction, diffusion et modification du document soient
  régis par la présente licence.<next-line><next-line><label|toc17>

  <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<\cell>
    <tabular|<tformat|<twith|table-width|1par>|<cwith|1|-1|1|-1|cell-hyphen|t>|<table|<row|<cell|<with|font-series|bold|7>>|<cell|<with|font-series|bold|Évolution
    de la license>>>>>>
  </cell>>>>>

  <label|secFin><next-line>La Guilde des Doctorants se réserve le droit de
  faire évoluer la présente license. Elle s'assurera de la compatibilité
  ascendante des différentes versions. Chaque version de la license est
  numérotée.<next-line><next-line><next-line><next-line><next-line>Sauf
  mention explicite, il est sous entendu que si le document précise un numéro
  de license, cela signifie que toute version ultérieure convient. Si aucun
  numéro n'est précisé, cela signifie que toute version de la license
  convient.<next-line><next-line><next-line><next-line><next-line>La présente
  license s'applique à elle-même. Vous pouvez donc la modifier, à condition
  d'en changer le titre et de préserver comme <em|section historique>
  l'introduction. Vous devez également préserver le plan du présent
  document.<next-line><next-line>

  \;

  \;

  \;

  \;
</body>

<\initial>
  <\collection>
    <associate|bg-color|white>
    <associate|font|roman>
    <associate|language|french>
    <associate|page-medium|paper>
    <associate|page-show-hf|true>
    <associate|preamble|false>
  </collection>
</initial>

<\references>
  <\collection>
    <associate|auto-1|<tuple|1|2>>
    <associate|auto-10|<tuple|5.2|3>>
    <associate|auto-11|<tuple|6|3>>
    <associate|auto-12|<tuple|6.1|3>>
    <associate|auto-13|<tuple|6.1.1|3>>
    <associate|auto-14|<tuple|1|4>>
    <associate|auto-15|<tuple|6.1.2|4>>
    <associate|auto-16|<tuple|2|4>>
    <associate|auto-17|<tuple|3|5>>
    <associate|auto-18|<tuple|6.2|5>>
    <associate|auto-19|<tuple|6.2.1|5>>
    <associate|auto-2|<tuple|2|3>>
    <associate|auto-20|<tuple|4|6>>
    <associate|auto-21|<tuple|6.2.2|6>>
    <associate|auto-22|<tuple|7|7>>
    <associate|auto-23|<tuple|7.1|7>>
    <associate|auto-24|<tuple|7.1.1|7>>
    <associate|auto-25|<tuple|7.1.2|7>>
    <associate|auto-26|<tuple|7.2|7>>
    <associate|auto-27|<tuple|7.2.1|7>>
    <associate|auto-28|<tuple|7.2.2|7>>
    <associate|auto-29|<tuple|8|8>>
    <associate|auto-3|<tuple|2|1>>
    <associate|auto-30|<tuple|8.1|8>>
    <associate|auto-31|<tuple|8.1.1|8>>
    <associate|auto-32|<tuple|8.1.2|12>>
    <associate|auto-33|<tuple|8.1.3|14>>
    <associate|auto-34|<tuple|8.2|17>>
    <associate|auto-35|<tuple|8.2.1|17>>
    <associate|auto-36|<tuple|8.2.2|25>>
    <associate|auto-37|<tuple|8.3|27>>
    <associate|auto-38|<tuple|8.3.1|27>>
    <associate|auto-39|<tuple|8.3.2|29>>
    <associate|auto-4|<tuple|3|1>>
    <associate|auto-40|<tuple|8.3.3|33>>
    <associate|auto-41|<tuple|8.3.4|34>>
    <associate|auto-42|<tuple|8.3.5|36>>
    <associate|auto-43|<tuple|8.4|37>>
    <associate|auto-44|<tuple|9|38>>
    <associate|auto-45|<tuple|10|39>>
    <associate|auto-5|<tuple|4|1>>
    <associate|auto-6|<tuple|4.1|1>>
    <associate|auto-7|<tuple|4.2|2>>
    <associate|auto-8|<tuple|5|2>>
    <associate|auto-9|<tuple|5.1|2>>
    <associate|gly-1|<tuple|1|4>>
    <associate|gly-2|<tuple|2|5>>
    <associate|gly-3|<tuple|3|6>>
    <associate|gly-4|<tuple|4|7>>
    <associate|gly-5|<tuple|5|?>>
    <associate|secCommon|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|secDefinitions|<tuple|10|?>>
    <associate|secFin|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|secFusion|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|secIncludes|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|secModifs|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|secModifsGenerales|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|secTraduction|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|text2|<tuple|10|?>>
    <associate|text3|<tuple|10|?>>
    <associate|text4|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|toc-1|<tuple|<uninit>|2>>
    <associate|toc-10|<tuple|<uninit>|3>>
    <associate|toc-11|<tuple|<uninit>|3>>
    <associate|toc-12|<tuple|<uninit>|3>>
    <associate|toc-13|<tuple|1|4>>
    <associate|toc-14|<tuple|3|7>>
    <associate|toc-15|<tuple|3|7>>
    <associate|toc-16|<tuple|4|8>>
    <associate|toc-17|<tuple|4|9>>
    <associate|toc-18|<tuple|4|9>>
    <associate|toc-19|<tuple|4|9>>
    <associate|toc-2|<tuple|<uninit>|3>>
    <associate|toc-20|<tuple|4|9>>
    <associate|toc-21|<tuple|4|9>>
    <associate|toc-22|<tuple|4|9>>
    <associate|toc-23|<tuple|4|9>>
    <associate|toc-24|<tuple|4|10>>
    <associate|toc-25|<tuple|4|10>>
    <associate|toc-26|<tuple|4|10>>
    <associate|toc-27|<tuple|4|14>>
    <associate|toc-28|<tuple|4|16>>
    <associate|toc-29|<tuple|4|19>>
    <associate|toc-3|<tuple|<uninit>|1>>
    <associate|toc-30|<tuple|4|19>>
    <associate|toc-31|<tuple|4|27>>
    <associate|toc-32|<tuple|4|29>>
    <associate|toc-33|<tuple|4|29>>
    <associate|toc-34|<tuple|4|31>>
    <associate|toc-35|<tuple|4|35>>
    <associate|toc-36|<tuple|4|36>>
    <associate|toc-37|<tuple|4|38>>
    <associate|toc-38|<tuple|4|39>>
    <associate|toc-39|<tuple|4|40>>
    <associate|toc-4|<tuple|<uninit>|1>>
    <associate|toc-40|<tuple|4|41>>
    <associate|toc-41|<tuple|4|?>>
    <associate|toc-5|<tuple|<uninit>|1>>
    <associate|toc-6|<tuple|<uninit>|2>>
    <associate|toc-7|<tuple|<uninit>|2>>
    <associate|toc-8|<tuple|<uninit>|2>>
    <associate|toc-9|<tuple|<uninit>|3>>
    <associate|toc11|<tuple|10|?>>
    <associate|toc12|<tuple|10|?>>
    <associate|toc13|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|toc14|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|toc15|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|toc16|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
    <associate|toc17|<tuple|<with|mode|<quote|math>|\<bullet\>>|?>>
  </collection>
</references>

<\auxiliary>
  <\collection>
    <\associate|figure>
      <tuple|normal|Exemple de calcul|<pageref|auto-14>>

      <tuple|normal|Impression écran du logiciel TeXmacs|<pageref|auto-16>>

      <tuple|normal|Utilisation d'une session Axiom dans
      TeXmacs|<pageref|auto-17>>

      <tuple|normal| Exemple d'affichage d'une courbe ( Environnement KDE
      )|<pageref|auto-20>>
    </associate>
    <\associate|toc>
      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Remerciements>
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-1><vspace|0.5fn>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Introduction>
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-2><vspace|0.5fn>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Table
      des matières> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-3><vspace|0.5fn>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Déterminati<assign|page-nr|<quote|1>>on
      des logiciels utilisés> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-4><vspace|0.5fn>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Présentation
      générale des logiciels> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-5><vspace|0.5fn>

      <with|par-left|<quote|1.5fn>|Axiom Computer Algebra System
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-6>>

      <with|par-left|<quote|1.5fn>|GNUplot
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-7>>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Informations
      sur les logiciels> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-8><vspace|0.5fn>

      <with|par-left|<quote|1.5fn>|Axiom <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-9>>

      <with|par-left|<quote|1.5fn>|GNUplot
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-10>>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Ergonomie:
      Prise en main> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-11><vspace|0.5fn>

      <with|par-left|<quote|1.5fn>|Axiom <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-12>>

      <with|par-left|<quote|3fn>|Mode Console
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-13>>

      <with|par-left|<quote|3fn>|Intégration à TeXmacs
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-15>>

      <with|par-left|<quote|1.5fn>|GNUplot
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-18>>

      <with|par-left|<quote|3fn>|Prise en main
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-19>>

      <with|par-left|<quote|3fn>|Intégration dans TeXmacs
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-21>>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Prise
      en main du logiciel> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-22><vspace|0.5fn>

      <with|par-left|<quote|1.5fn>|Axiom <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-23>>

      <with|par-left|<quote|3fn>|Premiers pas
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-24>>

      <with|par-left|<quote|3fn>|Recherche de solutions
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-25>>

      <with|par-left|<quote|1.5fn>|GNUplot
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-26>>

      <with|par-left|<quote|3fn>|Premiers pas
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-27>>

      <with|par-left|<quote|3fn>|Recherche de solutions
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-28>>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Résolution
      des TPs MT26> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-29><vspace|0.5fn>

      <with|par-left|<quote|1.5fn>|Instructions Maple
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-30>>

      <with|par-left|<quote|3fn>|Instructions d'algèbre
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-31>>

      <with|par-left|<quote|3fn>|Instructions d'analyse
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-32>>

      <with|par-left|<quote|3fn>|Instructions d'algèbre linéaire
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-33>>

      <with|par-left|<quote|1.5fn>|Graphiques
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-34>>

      <with|par-left|<quote|3fn>|Courbes dans le plan
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-35>>

      <with|par-left|<quote|3fn>|Surfaces dans l'espace
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-36>>

      <with|par-left|<quote|1.5fn>|Programmation
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-37>>

      <with|par-left|<quote|3fn>|Suites <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-38>>

      <with|par-left|<quote|3fn>|Sommes de séries
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-39>>

      <with|par-left|<quote|3fn>|Arithmétique
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-40>>

      <with|par-left|<quote|3fn>|Algèbre <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-41>>

      <with|par-left|<quote|3fn>|Procédures
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-42>>

      <with|par-left|<quote|1.5fn>|Calculs du programme MT26
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-43>>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Conclusion
      > <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-44><vspace|0.5fn>

      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Annexes>
      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
      <pageref|auto-45><vspace|0.5fn>
    </associate>
  </collection>
</auxiliary>