<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY app "<application>Genius Mathematics Tool</application>">
<!ENTITY appname "Genius">
<!ENTITY appversion "1.0.21">
<!ENTITY date "January 2016">
<!ENTITY legal SYSTEM "legal.xml">
<!ENTITY manrevision "0.2">
<!ENTITY lt "&#60;">
<!ENTITY gt "&#62;">
<!ENTITY le "&#8804;">
<!ENTITY ge "&#8805;">
<!ENTITY lsquo "&#8216;">
<!ENTITY rsquo "&#8217;">
<!--<!ENTITY gel-function-list SYSTEM "gel-function-list.xml">-->]>
<!-- 
      (Do not remove this comment block.)
  Maintained by the GNOME Documentation Project
  http://developer.gnome.org/projects/gdp
  Template version: 2.0 beta
  Template last modified Apr 11, 2002
-->
<!-- =============Document Header ============================= -->
<book id="index" lang="fr">
<!-- please do not change the id; for translations, change lang to -->
<!-- appropriate code -->
  <bookinfo>
	  <abstract role="description"><para>Manuel de l'Outil de maths Genius.</para></abstract>
    <title>Manuel de Genius</title>       

    <copyright>
      <year>1997-2016</year>
      <holder>Jiří (George) Lebl</holder>
    </copyright>
    <copyright>
      <year>2004</year>
      <holder>Kai Willadsen</holder>
    </copyright><copyright><year>2010-11</year><holder>Bruno Brouard (annoa.b@gmail.com)</holder></copyright><copyright><year>2011</year><holder>Luc Pionchon (pionchon.luc@gmail.com)</holder></copyright>
<!-- translators: uncomment this:
  <copyright>
   <year>2002</year>
   <holder>ME-THE-TRANSLATOR (Latin translation)</holder>
  </copyright>
-->

    <publisher> 
      <publishername/> 
    </publisher> 

     <legalnotice id="legalnotice">
	<para>Permission vous est donnée de copier, distribuer et/ou modifier ce document selon les termes de la Licence GNU Free Documentation License, Version 1.1 ou ultérieure publiée par la Free Software Foundation sans section inaltérable, sans texte de première page de couverture ni texte de dernière page de couverture. Vous trouverez un exemplaire de cette licence en suivant ce <ulink type="help" url="ghelp:fdl">lien</ulink> ou dans le fichier COPYING-DOCS fourni avec le présent manuel.</para>
         <para>Ce manuel fait partie de la collection de manuels GNOME distribués selon les termes de la licence de documentation libre GNU. Si vous souhaitez distribuer ce manuel indépendamment de la collection, vous devez joindre un exemplaire de la licence au document, comme indiqué dans la section 6 de celle-ci.</para>

	<para>La plupart des noms utilisés par les entreprises pour distinguer leurs produits et services sont des marques déposées. Lorsque ces noms apparaissent dans la documentation GNOME et que les membres du projet de Documentation GNOME sont informés de l'existence de ces marques déposées, soit ces noms entiers, soit leur première lettre est en majuscule.</para>

	<para>LE PRÉSENT DOCUMENT ET SES VERSIONS MODIFIÉES SONT FOURNIS SELON LES TERMES DE LA LICENCE DE DOCUMENTATION LIBRE GNU SACHANT QUE : <orderedlist>
		<listitem>
		  <para>LE PRÉSENT DOCUMENT EST FOURNI « TEL QUEL », SANS AUCUNE GARANTIE, EXPRESSE OU IMPLICITE, Y COMPRIS, ET SANS LIMITATION, LES GARANTIES DE MARCHANDABILITÉ, D'ADÉQUATION À UN OBJECTIF PARTICULIER OU DE NON INFRACTION DU DOCUMENT OU DE SA VERSION MODIFIÉE. L'UTILISATEUR ASSUME TOUT RISQUE RELATIF À LA QUALITÉ, À LA PERTINENCE ET À LA PERFORMANCE DU DOCUMENT OU DE SA VERSION DE MISE À JOUR. SI LE DOCUMENT OU SA VERSION MODIFIÉE S'AVÉRAIT DÉFECTUEUSE, L'UTILISATEUR (ET NON LE RÉDACTEUR INITIAL, L'AUTEUR, NI TOUT AUTRE PARTICIPANT) ENDOSSERA LES COÛTS DE TOUTE INTERVENTION, RÉPARATION OU CORRECTION NÉCESSAIRE. CETTE DÉNÉGATION DE RESPONSABILITÉ CONSTITUE UNE PARTIE ESSENTIELLE DE CETTE LICENCE. AUCUNE UTILISATION DE CE DOCUMENT OU DE SA VERSION MODIFIÉE N'EST AUTORISÉE AUX TERMES DU PRÉSENT ACCORD, EXCEPTÉ SOUS CETTE DÉNÉGATION DE RESPONSABILITÉ ; </para>
		</listitem>
		<listitem>
		  <para>EN AUCUNE CIRCONSTANCE ET SOUS AUCUNE INTERPRÉTATION DE LA LOI, QU'IL S'AGISSE D'UN DÉLIT CIVIL (Y COMPRIS LA NÉGLIGENCE), CONTRACTUEL OU AUTRE, L'AUTEUR, LE RÉDACTEUR INITIAL, TOUT PARTICIPANT OU TOUT DISTRIBUTEUR DE CE DOCUMENT OU DE SA VERSION MODIFIÉE, OU TOUT FOURNISSEUR DE L'UNE DE CES PARTIES NE POURRA ÊTRE TENU RESPONSABLE À L'ÉGARD DE QUICONQUE POUR TOUT DOMMAGE DIRECT, INDIRECT, PARTICULIER, OU ACCIDENTEL DE TOUT TYPE Y COMPRIS, SANS LIMITATION, LES DOMMAGES LIÉS À LA PERTE DE CLIENTÈLE, À UN ARRÊT DE TRAVAIL, À UNE DÉFAILLANCE OU UN MAUVAIS FONCTIONNEMENT INFORMATIQUE, OU À TOUT AUTRE DOMMAGE OU PERTE LIÉE À L'UTILISATION DU DOCUMENT ET DE SES VERSIONS MODIFIÉES, MÊME SI LADITE PARTIE A ÉTÉ INFORMÉE DE L'ÉVENTUALITÉ DE TELS DOMMAGES.</para>
		</listitem>
	  </orderedlist></para>
  </legalnotice>


   <!-- This file  contains link to license for the documentation (GNU FDL), and 
        other legal stuff such as "NO WARRANTY" statement. Please do not change 
	any of this. -->

    <authorgroup> 
      <author role="maintainer"> 
		<firstname>Jiří</firstname> 
		<surname>Lebl</surname> 
		<affiliation> 
	  		<orgname>Oklahoma State University</orgname> 
	  		<address> <email>jirka@5z.com</email> </address> 
		</affiliation> 
      </author> 
      <author> 
		<firstname>Kai</firstname> 
		<surname>Willadsen</surname> 
		<affiliation> 
	  		<orgname>Université de Queensland, Australie</orgname> 
	  		<address> <email>kaiw@itee.uq.edu.au</email> </address> 
		</affiliation> 
      </author> 
      
<!-- This is appropriate place for other contributors: translators,
     maintainers,  etc. Commented out by default.
     
      <othercredit role="translator">
		<firstname>Latin</firstname> 
		<surname>Translator 1</surname> 
		<affiliation> 
	  		<orgname>Latin Translation Team</orgname> 
	  		<address> <email>translator@gnome.org</email> </address> 
		</affiliation>
		<contrib>Latin translation</contrib>
      </othercredit>
-->
    </authorgroup>


<!-- According to GNU FDL, revision history is mandatory if you are -->
<!-- modifying/reusing someone else's document.  If not, you can omit it. -->
<!-- Remember to remove the &manrevision; entity from the revision entries other
-->
<!-- than the current revision. -->
<!-- The revision numbering system for GNOME manuals is as follows: -->
<!-- * the revision number consists of two components -->
<!-- * the first component of the revision number reflects the release version of the GNOME desktop. -->
<!-- * the second component of the revision number is a decimal unit that is incremented with each revision of the manual. -->
<!-- For example, if the GNOME desktop release is V2.x, the first version of the manual that -->
<!-- is written in that desktop timeframe is V2.0, the second version of the manual is V2.1, etc. -->
<!-- When the desktop release version changes to V3.x, the revision number of the manual changes -->
<!-- to V3.0, and so on. -->  
<!--  This is unmaintained quite a bit so screw this it just makes things
      ugly and we don't update the manrevision stuff anyway
    <revhistory>
      <revision> 
		<revnumber>&manrevision;</revnumber> 
		<date>&date;</date> 
		<revdescription> 
	  		<para role="author">Jiri (George) Lebl
	    	<email>jirka@5z.com</email>
	  		</para>
		</revdescription> 
      </revision> 
      <revision> 
		<revnumber>0.1</revnumber> 
		<date>September 2004</date> 
		<revdescription> 
	  		<para role="author">Kai Willadsen
	    	<email>kaiw@itee.uq.edu.au</email>
	  		</para>
		</revdescription> 
      </revision> 
      <revision> 
		<revnumber>Genius Calculator Manual</revnumber> 
		<date>August 2004</date> 
		<revdescription> 
	  		<para role="author">Jiri (George) Lebl
	    	<email>jirka@5z.com</email>
	  		</para>
		</revdescription> 
      </revision> 
    </revhistory> 
-->

    <revhistory>
      <revision> 
		<revnumber>0.2</revnumber> 
		<date>January 2016</date> 
		<revdescription> 
	  		<para role="author">Jiri (George) Lebl <email>jirka@5z.com</email></para>
		</revdescription> 
      </revision> 
    </revhistory>
    <releaseinfo>This manual describes version 1.0.21 of Genius.
    </releaseinfo> 
    <legalnotice> 
      <title>Votre avis</title> 
      <para>
	      To report a bug or make a suggestion regarding the <application>Genius Mathematics Tool</application>
	      application or this manual, please visit the
	      <ulink url="http://www.jirka.org/genius.html" type="http">Genius
		      Web page</ulink>
	      or email me at <email>jirka@5z.com</email>.
      </para>
<!-- Translators may also add here feedback address for translations -->
    </legalnotice> 
  </bookinfo> 

<!-- ============= Introduction =============================== -->
  <chapter id="genius-introduction"> 
    <title>Introduction</title> 
    <para>L'application <application>Outil de maths Genius</application> est un calculateur générique qui peut être utilisé comme calculatrice de bureau, outil éducatif en mathématiques et peut même être utile pour la recherche. Le langage utilisé dans l'<application>Outil de maths Genius</application> a été conçu pour être « mathématique » dans le sens où il devrait être « what you mean is what you get » (« ce que vous pensez est ce que vous obtenez »). C'est bien sûr un objectif pas complètement atteignable. L'<application>Outil de maths Genius</application> peut utiliser des rationnels, des entiers de précision arbitraire et des nombres à virgule flottante avec différentes précisions en utilisant la bibliothèque GMP. Il prend en charge les nombres complexes en utilisant la notation cartésienne. Il sait comment manipuler correctement les vecteurs et les matrices et prend en charge l'algèbre linéaire élémentaire. Le langage de programmation autorise la définition de fonctions et de variables utilisateurs et la modification de certains paramètres.</para> 

    <para>Il existe deux versions de l'<application>Outil de maths Genius</application>. L'une est la version graphique de GNOME qui inclut une interface de style IDE et la possibilité de tracer des fonctions à une ou deux variables. L'autre, la version en ligne de commande, n'a pas besoin de GNOME mais bien sûr, elle n'implémente aucune fonctionnalité qui requiert l'interface graphique.</para> 

    <para>
	    Parts of this manual describe the graphical version of the calculator,
	but the language is of course the same.  The command line only version
	lacks the graphing capabilities and all other capabilities that require
	the graphical user interface.
    </para>

    <para>
	    Generally, when some feature of the language (function, operator, etc...)
	    is new is some version past 1.0.5, it is mentioned, but
	    below 1.0.5 you would have to look at the NEWS file.
    </para>

  </chapter>

<!-- =========== Getting Started ============================== -->
  <chapter id="genius-getting-started"> 
    <title>Premiers pas</title> 

    <sect1 id="genius-to-start">
      <title>Lancement de l'<application>Outil de maths Genius</application></title>
      <para>Vous pouvez démarrer l'<application>Outil de maths Genius</application> d'une des manières suivantes :</para> 
      <variablelist>
        <varlistentry>
          <term>Menu <guimenu>Applications</guimenu></term>
          <listitem>
	    <para>En fonction de votre système d'exploitation et de sa version, l'élément de menu pour l'<application>Outil de maths Genius</application> peut apparaître à différents endroits. Cela peut être dans les sous-menus <guisubmenu>Éducation</guisubmenu>, <guisubmenu>Accessoires</guisubmenu>, <guisubmenu>Bureautique</guisubmenu>, <guisubmenu>Science</guisubmenu> ou d'autres similaires en fonction de vos réglages personnels. Le nom de l'entrée de menu que vous recherchez est <application>Outil de maths Genius</application>. Une fois localisé, cliquez dessus pour démarrer l'<application>Outil de maths Genius</application>.</para>
	      </listitem>
        </varlistentry>
        <varlistentry>
          <term>Boîte de dialogue <guilabel>Lancer une application</guilabel></term>
          <listitem>
	    <para>Il se peut que l'entrée de menu ne soit pas accessible pour votre système d'exploitation. Dans ce cas, vous pouvez ouvrir la boîte de dialogue <guilabel>Lancer une application</guilabel> et saisir <command>gnome-genius</command>.</para>
	      </listitem>
        </varlistentry>
        <varlistentry>
    	  <term>Ligne de commande</term>
    	  <listitem>
    	    <para>Pour démarrer la version GNOME de l'<application>Outil de maths Genius</application>, saisissez <command>gnome-genius</command>.</para>
	    <para>Pour démarrer seulement la version en ligne de commande, exécutez la commande <command>genius</command>. Cette version ne comprend pas d'environnement graphique et certaines fonctionnalités comme le tracé de graphiques ne sont pas disponibles.</para> 
          </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

    <sect1 id="genius-when-start">
    <title>Démarrage de Genius</title>
      <para>Lorsque vous démarrez la version GNOME de l'<application>Outil de maths Genius</application>, la fenêtre <xref linkend="mainwindow-fig"/> apparaît.</para>

      <figure id="mainwindow-fig"> 
        <title>Fenêtre de l'<application>Outil de maths Genius</application></title> 
        <screenshot> 
          <mediaobject> 
            <imageobject>
              <imagedata fileref="figures/genius_window.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
	      <phrase>Shows <application>Outil de maths Genius</application> main window. Contains titlebar, menubar,
toolbar and working area. Menubar contains <guilabel>Fichier</guilabel>,
<guilabel>Édition</guilabel>, <guilabel>Calculatrice</guilabel>,
<guilabel>Examples</guilabel>,
<guilabel>Programs</guilabel>,
<guilabel>Paramètres</guilabel>, and <guilabel>Aide</guilabel> menus.</phrase> 
            </textobject> 
          </mediaobject>
        </screenshot> 
      </figure>

      <para>La fenêtre de l'<application>Outil de maths Genius</application> contient les éléments suivants :</para>
      <variablelist>
        <varlistentry>
          <term>Barre de menus</term>
          <listitem>
            <para>Les menus de la barre de menus contiennent toutes les commandes dont vous aurez besoin pour travailler avec les fichiers dans l'<application>Outil de maths Genius</application>. Le menu <guilabel>Fichier</guilabel> contient les éléments pour charger et enregistrer des éléments et créer de nouveaux programmes. La commande <guilabel>Charger et exécuter...</guilabel> n'ouvre pas de nouvelle fenêtre pour le programme mais exécute seulement le programme directement. Elle est équivalente à la commande <command>load</command>.</para>
	    <para>
		The <guilabel>Calculator</guilabel> menu controls the
calculator engine.  It allows you to run the currently selected program or to
interrupt the current calculation.  You can also look at the full expression of
the last answer (useful if the last answer was too large to fit onto the
console), or you can view a listing of the values of all user defined
variables.  You can also monitor user variables, which is especially useful
while a long calculation is running, or to debug a certain program.
		    Finally the <guilabel>Calculator</guilabel> allows plotting functions using a user friendly dialog box.
	   </para>
	   <para>
		   The <guilabel>Examples</guilabel> menu is a list of example
		   programs or demos.  If you open the menu, it will load the
		   example into a new program, which you can run, edit, modify,
		   and save.  These programs should be well documented
		   and generally demonstrate some either feature of <application>Genius Mathematics Tool</application>
		   or some mathematical concept.
	   </para>
	   <para>
		   The <guilabel>Programs</guilabel> menu lists
		   the currently open programs and allows you to switch
		   between them.
	   </para>
	   <para>Les autres menus contiennent les mêmes fonctions classiques qui apparaissent dans d'autres applications.</para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Barre d'outils</term>
          <listitem>
            <para>La barre d'outils contient un sous-ensemble des commandes accessibles à partir de la barre de menus.</para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Zone de travail</term>
          <listitem>
            <para>La zone de travail est la principale méthode d'interaction avec l'application.</para>
	    <para>
	    	The working area initially has just the <guilabel>Console</guilabel> tab, which is
		the main way of interacting with the calculator.  Here you
		type expressions and the results are immediately returned
		after you hit the Enter key.
	    </para>
	    <para>
	    	Alternatively you can write longer programs and those can
		appear in separate tabs.  The programs are a set of commands or
	        functions that can be run all at once rather than entering them
		at the command line.  The programs can be saved in files for later
		retrieval.
	    </para>
          </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

  </chapter>

<!-- ================ Usage =================================== -->
  <chapter id="genius-usage"> 
    <title>Utilisation de base</title> 

    <sect1 id="genius-usage-workarea"> 
      <title>Utilisation de la zone de travail</title> 

      <para>
        Normally you interact with the calculator in the <guilabel>Console</guilabel> tab of the
	work area.  If you are running the text only version then the console
	will be the only thing that is available to you.  If you want to use
	<application>Genius Mathematics Tool</application> as a calculator only, just type in your expression in the console, it
	will be evaluated, and the returned value will be printed.
      </para>

      <para>
	      To evaluate an expression, type it into the <guilabel>Console</guilabel> work area and press enter.
	      Expressions are written in a
language called GEL.  The most simple GEL expression just looks like
mathematics.  For example
<screen><prompt>genius&gt; </prompt><userinput>30*70 + 67^3.0 + ln(7) * (88.8/100)</userinput>
</screen>
or
<screen><prompt>genius&gt; </prompt><userinput>62734 + 812634 + 77^4 mod 5</userinput>
</screen>
or
<screen><prompt>genius&gt; </prompt><userinput>| sin(37) - e^7 |</userinput>
</screen>
or
<screen><prompt>genius&gt; </prompt><userinput>sum n=1 to 70 do 1/n</userinput>
</screen>
(Last is the harmonic sum from 1 to 70)
</para>
<para>Pour obtenir une liste des fonctions et commandes, saisissez : <screen><prompt>genius&gt; </prompt><userinput>help</userinput>
</screen> Si vous souhaitez obtenir plus d'aide sur une fonction précise, saisissez : <screen><prompt>genius&gt; </prompt><userinput>help NomDeLaFonction</userinput>
</screen> Pour afficher ce manuel, saisissez : <screen><prompt>genius&gt; </prompt><userinput>manual</userinput>
</screen></para>
<para>
Suppose you have previously saved some GEL commands as a program to a file and
you now want to execute them.
To load this program from the file <filename>path/to/program.gel</filename>,
type
<screen><prompt>genius&gt; </prompt><userinput>load path/to/program.gel</userinput>
</screen>
<application>Genius Mathematics Tool</application> keeps track of the current directory.
To list files in the current directory type <command>ls</command>, to change directory
do <userinput>cd directory</userinput> as in the UNIX command shell.
</para>
    </sect1>

    <sect1 id="genius-usage-create-program"> 
      <title>Création d'un programme</title> 
      <para>
	      If you wish to enter several more complicated commands, or perhaps write a complicated
	      function using the <link linkend="genius-gel">GEL</link> language.  You can create a new
	     program.
      </para>
      <para>
To start writing a new program, choose
<menuchoice><guimenu>File</guimenu><guimenuitem>New
Program</guimenuitem></menuchoice>. A new tab will appear in the work area. You
can write a <link linkend="genius-gel">GEL</link> program in this work area.
Once you have written your program you can run it by 
<menuchoice><guimenu>Calculator</guimenu><guimenuitem>Run</guimenuitem></menuchoice> (or
the <guilabel>Run</guilabel> toolbar button).
This will execute your program and will display any output on the <guilabel>Console</guilabel> tab.
Executing a program is equivalent of taking the text of the program and
typing it into the console.  The only difference is that this input is done
independent of the console and just the output goes onto the console.
<menuchoice><guimenu>Calculator</guimenu><guimenuitem>Run</guimenuitem></menuchoice>
will always run the currently selected program even if you are on the <guilabel>Console</guilabel>
tab.  The currently selected program has its tab in bold type.  To select a
program, just click on its tab.
      </para>
      <para>
To save the program you've just written, choose <menuchoice><guimenu>File</guimenu><guimenuitem>Save As...</guimenuitem></menuchoice>.
Similarly as in other programs you can choose
<menuchoice><guimenu>File</guimenu><guimenuitem>Save</guimenuitem></menuchoice> to save a program that already has
a filename attached to it.  If you have many opened programs you have edited and wish to save you can also choose
<menuchoice><guimenu>File</guimenu><guimenuitem>Save All Unsaved</guimenuitem></menuchoice>.
      </para>
      <para>
	      Programs that have unsaved changes will have a "[+]" next to their filename.  This way you can see if the file
	      on disk and the currently opened tab differ in content.  Programs which have not yet had a filename associated
	      with them are always considered unsaved and no "[+]" is printed.
      </para>
    </sect1>

    <sect1 id="genius-usage-open-program"> 
      <title>Ouverture et lancement d'un programme</title> 
      <para>Pour ouvrir un fichier, choisissez <menuchoice><guimenu>Fichier</guimenu><guimenuitem>Ouvrir</guimenuitem></menuchoice>. Un nouvel onglet contenant le fichier apparaît dans la zone de travail. Vous pouvez l'utiliser pour modifier le fichier.</para>
      <para>Pour lancer un programme à partir d'un fichier, choisissez <menuchoice><guimenu>Fichier</guimenu><guimenuitem>Charger et exécuter...</guimenuitem></menuchoice>. Le programme est lancé sans être ouvert dans un onglet séparé. C'est équivalent à la commande <command>load</command>.</para>
      <para>
	      If you have made edits to a file you wish to throw away and want to reload to the version that's on disk,
	      you can choose the
	      <menuchoice><guimenu>File</guimenu><guimenuitem>Reload from Disk</guimenuitem></menuchoice> menuitem.  This is useful for experimenting
	      with a program and making temporary edits, to run a program, but that you do not intend to keep.
      </para>
    </sect1>

  </chapter>

  <!-- ============= Plotting ============================== -->
  <chapter id="genius-gel-plotting">
    <title>Tracé de graphiques</title>

    <para>Le tracé de graphiques n'est disponible que dans la version graphique GNOME. Tous les tracés accessibles à partir de l'interface graphique sont disponibles à partir de la fenêtre <guilabel>Création de graphiques</guilabel>. Vous pouvez accéder à cette fenêtre, soit en cliquant sur le bouton <guilabel>Tracer</guilabel> de la barre d'outils ou en sélectionnant <guilabel>Tracer</guilabel> dans le menu <guilabel>Calculateur</guilabel>. Vous pouvez également accéder aux fonctionnalités de tracer en utilisant les <link linkend="genius-gel-function-list-plotting">fonctions de tracé</link> du langage GEL. Consultez <xref linkend="genius-gel"/> pour apprendre comment saisir des expressions compréhensibles par Genius.</para>

    <sect1 id="genius-line-plots">
      <title>Tracé de lignes</title>
      <para>Pour tracer des fonctions réelles d'une variable, ouvrez la fenêtre <guilabel>Création de graphiques</guilabel>. Vous pouvez aussi utiliser la fonction <link linkend="gel-function-LinePlot"><function>LinePlot</function></link> en ligne de commande (consultez sa documentation).</para>
      <para>Une fois que vous avez cliqué sur le bouton <guilabel>Tracer</guilabel>, une fenêtre contenant des onglets apparaît. Vous devez être dans l'onglet <guilabel>Tracé de lignes</guilabel> et dans celui-ci, vous devez être dans l'onglet <guilabel>Fonctions / Expressions</guilabel> (consultez <xref linkend="lineplot-fig"/>).</para>

      <figure id="lineplot-fig"> 
        <title>Fenêtre Création de graphiques</title> 
        <screenshot> 
          <mediaobject> 
            <imageobject>
              <imagedata fileref="figures/line_plot.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Affiche la fenêtre pour tracer des graphiques.</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

      <para>
	Type expressions with <userinput>x</userinput> as
	the independent variable into the textboxes.  Alternatively you can give names of functions such as
	<userinput>cos</userinput> rather then having to type <userinput>cos(x)</userinput>.
	You can graph up to ten functions.  If you make a mistake and Genius cannot
	parse the input it will signify this with a warning icon on the right of the text
	input box where the error occurred, as well as giving you an error dialog.
	You can change the ranges of the dependent and independent variables in the bottom
	part of the dialog.
	The <varname>y</varname> (dependent) range can be set automatically by turning on the <guilabel>Fit dependent axis</guilabel>
	checkbox.
	The names of the variables can also be changed.
	Pressing the <guilabel>Plot</guilabel> button produces the graph shown in <xref linkend="lineplot2-fig"/>.
      </para>
      <para>
	      The variables can be renamed by clicking the <guilabel>Change variable names...</guilabel> button, which is useful if you wish to print or save the figure and don't want to use the standard
	      names.  Finally you can also avoid printing the legend and the axis labels completely,
	      which is also useful if printing or
	      saving, when the legend might simply be clutter.
      </para>

      <figure id="lineplot2-fig"> 
        <title>Fenêtre contenant une courbe</title> 
        <screenshot> 
          <mediaobject> 
            <imageobject>
              <imagedata fileref="figures/line_plot_graph.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Le graphe produit.</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

      <para>À partir de là, vous pouvez imprimer le graphe, créer une version postscript encapsulé ou PNG du graphe ou modifier le zoom. Si l'axe dépendant n'a pas été configuré correctement, Genius peut l'avoir ajusté en cherchant les extrema des fonctions tracées.</para>

      <para>Pour tracer à partir de la ligne de commande, consultez la documentation de la fonction <link linkend="gel-function-LinePlot"><function>LinePlot</function></link>.</para>
    </sect1>

    <sect1 id="genius-parametric-plots">
      <title>Courbes paramétriques</title>
      <para>
	In the create plot window, you can also choose the <guilabel>Parametric</guilabel> notebook
        tab to create two dimensional parametric plots.  This way you can
	plot a single parametric function.  You can either specify the
	points as <varname>x</varname> and <varname>y</varname>, or giving a single complex number
	as a function of the variable <varname>t</varname>.
	The range of the variable <varname>t</varname> is given explicitly, and the function is sampled
	according to the given increment.
	The <varname>x</varname> and <varname>y</varname> range can be set
	automatically by turning on the <guilabel>Fit dependent axis</guilabel>
	checkbox, or it can be specified explicitly.
	See <xref linkend="paramplot-fig"/>.
      </para>

      <figure id="paramplot-fig"> 
        <title>Onglet pour les courbes paramétriques</title> 
        <screenshot> 
          <mediaobject> 
            <imageobject>
              <imagedata fileref="figures/parametric.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Onglet pour tracer paramétrique dans la fenêtre <guilabel>Création de graphiques</guilabel>.</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

      <para>
	An example of a parametric plot is given in
	<xref linkend="paramplot2-fig"/>.
	Similar operations can be
	done on such graphs as can be done on the other line plots.
	For plotting using the command line see the documentation of the
        <link linkend="gel-function-LinePlotParametric"><function>LinePlotParametric</function></link> or
        <link linkend="gel-function-LinePlotCParametric"><function>LinePlotCParametric</function></link> function.
      </para>

      <figure id="paramplot2-fig"> 
        <title>Courbe paramétrique</title> 
        <screenshot> 
          <mediaobject> 
            <imageobject>
              <imagedata fileref="figures/parametric_graph.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Courbe paramétrique produite</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

    </sect1>

    <sect1 id="genius-slopefield-plots">
      <title>Champ de directions</title>
      <para>Dans la fenêtre de création de graphiques, vous pouvez également sélectionner l'onglet <guilabel>Champ de directions</guilabel> pour créer un graphique de champ de directions à deux dimensions. Des opérations, similaires à celles qui peuvent être réalisées sur les tracés de lignes, peuvent être réalisées sur des graphiques de ce type. Pour réaliser des graphiques en ligne de commande, consultez la documentation de la fonction <link linkend="gel-function-SlopefieldPlot"><function>SlopefieldPlot</function></link>.</para>

      <para>Quand un champ de directions est actif, un menu supplémentaire <guilabel>Solveur</guilabel> est disponible, il vous permet d'afficher la boîte de dialogue du solveur. Dans celle-ci, vous pouvez faire tracer à Genius des solutions spécifiques pour les conditions initiales fournies. Vous pouvez soit indiquer des conditions initiales spécifiques dans la boîte de dialogue ou cliquer sur le graphique directement pour indiquer le point de départ. Tant que la boîte de dialogue du solveur est active, la fonction de zoom par clic et déplacement ne fonctionne pas. Vous devez d'abord fermer la boîte de dialogue si vous voulez zoomer avec votre souris.</para>

      <para>Le solveur utilise la méthode standard de Runge-Kutta. Les graphiques restent sur l'écran jusqu'à ce qu'ils soient effacés. Le solveur s'arrête à chaque fois qu'il atteint les limites de la fenêtre du graphique. Le fait de zoomer ne modifie pas les limites ou paramètres des solutions, vous devez les effacer et les redessiner avec les paramètres appropriés. Vous pouvez utiliser la fonction <link linkend="gel-function-SlopefieldDrawSolution"><function>SlopefieldDrawSolution</function></link> pour tracer les solutions à partir de la ligne de commande ou dans des programmes.</para>

    </sect1>

    <sect1 id="genius-vectorfield-plots">
      <title>Champ de vecteurs</title>
      <para>Dans la fenêtre de création de graphiques, vous pouvez également sélectionner l'onglet <guilabel>Champ de vecteurs</guilabel> pour créer un graphique de champ de vecteurs à deux dimensions. Des opérations, similaires à celles qui peuvent être réalisées sur les tracés de lignes, peuvent être réalisées sur des graphiques de ce type. Pour réaliser des graphiques en ligne de commande, consultez la documentation de la fonction <link linkend="gel-function-VectorfieldPlot"><function>VectorfieldPlot</function></link>.</para>

      <para>Par défaut, la direction et l'amplitude du champ de vecteurs sont affichées. Pour n'afficher que la direction, cochez la case appropriée pour normaliser la longueur des flèches.</para>

      <para>Quand un champ de vecteurs est actif, un menu supplémentaire <guilabel>Solveur</guilabel> est disponible, vous permettant d'afficher la boîte de dialogue du solveur. Dans celle-ci, vous pouvez faire tracer à Genius des solutions spécifiques pour les conditions initiales fournies. Vous pouvez soit indiquer des conditions initiales spécifiques dans la boîte de dialogue ou cliquer sur le graphique directement pour indiquer le point de départ. Tant que la boîte de dialogue du solveur est active, la fonction de zoom par clic et déplacement ne fonctionne pas. Vous devez d'abord fermer la boîte de dialogue si vous voulez zoomer avec votre souris.</para>

      <para>Le solveur utilise la méthode standard de Runge-Kutta. Les graphiques restent sur l'écran jusqu'à ce qu'ils soient effacés. Le fait de zoomer ne modifie pas les limites ou paramètres des solutions, vous devez effacer et les redessiner avec les paramètres appropriés. Vous pouvez utiliser la fonction <link linkend="gel-function-VectorfieldDrawSolution"><function>VectorfieldDrawSolution</function></link> pour tracer les solutions à partir de la ligne de commande ou dans des programmes.</para>

    </sect1>

    <sect1 id="genius-surface-plots">
      <title>Tracé de surfaces</title>
      <para>
	Genius can also plot surfaces.  Select the <guilabel>Surface plot</guilabel> tab in the
	main notebook of the <guilabel>Create Plot</guilabel> window.  Here you can specify a single
	expression that should use either <varname>x</varname> and <varname>y</varname> as real independent variables
	or <varname>z</varname> as a complex variable (where <varname>x</varname> is the real part of <varname>z</varname> and <varname>y</varname> is the
	imaginary part).  For example to plot the modulus of the cosine
	function for complex parameters,
	you could enter <userinput>|cos(z)|</userinput>.  This would be
	equivalent to <userinput>|cos(x+1i*y)|</userinput>.
	See <xref linkend="surfaceplot-fig"/>.
	For plotting using the command line see the documentation of the
        <link linkend="gel-function-SurfacePlot"><function>SurfacePlot</function></link> function.
      </para>
      <para>
	      The <varname>z</varname> range can be set automatically by turning on the <guilabel>Fit dependent axis</guilabel>
	      checkbox.  The variables can be renamed by clicking the <guilabel>Change variable names...</guilabel> button, which is useful if you wish to print or save the figure and don't want to use the standard
	      names.  Finally you can also avoid printing the legend, which is also useful if printing or
	      saving, when the legend might simply be clutter.
      </para>

      <figure id="surfaceplot-fig"> 
        <title>Graphique de surface</title> 
        <screenshot> 
          <mediaobject> 
            <imageobject>
              <imagedata fileref="figures/surface_graph.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Module de la fonction cosinus complex.</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

      <para>
	      In surface mode, left and right arrow keys on your keyboard will rotate the
	      view along the z axis.  Alternatively you can rotate along any axis by
	      selecting <guilabel>Rotate axis...</guilabel> in the <guilabel>View</guilabel> 
	      menu.  The <guilabel>View</guilabel> menu also has a top view mode which rotates the
	      graph so that the z axis is facing straight out, that is, we view the graph from the top
	      and get essentially just the colors that define the values of the function getting a
	      temperature plot of the function.  Finally you should
	      try <guilabel>Start rotate animation</guilabel>, to start a continuous slow rotation.
	      This is especially good if using <application>Genius Mathematics Tool</application> to present to an audience.
      </para>

    </sect1>

  </chapter>

  <!-- ============= GEL ====================================== -->
  <chapter id="genius-gel"> 
    <title>Fondamentaux GEL</title> 

	<para>
	  GEL stands for Genius Extension Language.    It is the language you use
	  to write programs in Genius. A program in GEL is simply an
	  expression that evaluates to a number, a matrix, or another object
	  in GEL.
	  <application>Genius Mathematics Tool</application> can be used as a simple calculator, or as a
	  powerful theoretical research tool.  The syntax is meant to
	  have as shallow of a learning curve as possible, especially for use
	  as a calculator.
	</para>

    <sect1 id="genius-gel-values">
      <title>Types de données</title>

      <para>
	      Values in GEL can be <link linkend="genius-gel-values-numbers">numbers</link>, <link linkend="genius-gel-values-booleans">Booleans</link>, or <link linkend="genius-gel-values-strings">strings</link>.   GEL also treats 
<link linkend="genius-gel-matrices">matrices</link> as values.
	      Values can be used in calculations, assigned to variables and returned from functions, among other uses.
      </para>

      <sect2 id="genius-gel-values-numbers">
        <title>Nombres</title>
        <para>Les entiers sont les premiers types de nombres GEL. Les entiers s'écrivent de façon habituelle. <programlisting>1234
</programlisting> Les nombres hexadécimaux et octaux peuvent être écrit à la manière du langage C. Par exemple : <programlisting>0x123ABC
01234
</programlisting> Vous pouvez aussi saisir des nombres dans n'importe quelle base en utilisant la notation <literal>&lt;base&gt;\&lt;nombre&gt;</literal>. Les chiffres plus grands que 10 utilisent des lettres tout comme pour l'hexadécimal. Par exemple, un nombre en base 23 pourrait s'écrire : <programlisting>23\1234ABCD
</programlisting></para>

        <para>Le deuxième type de nombres en GEL est celui des rationnels. Les rationnels sont simplement obtenus en divisant deux entiers. Il serait donc possible d'écrire : <programlisting>3/4
</programlisting> pour obtenir trois quarts. Les rationnels acceptent également la notation fractionnelle mixte, donc afin d'obtenir un et trois dixièmes, vous pouvez écrire : <programlisting>1 3/10
</programlisting></para>

        <para>Le type suivant est celui des nombres à virgule flottante. Ils sont saisis de la même manière qu'en C. Vous pouvez utiliser <literal>E</literal>, <literal>e</literal> ou <literal>@</literal> pour délimiter l'exposant. Notez que l'utilisation d'un délimiteur d'exposant implique un flottant même s'il n'y a pas de point séparateur des décimales dans le nombre. Exemples : <programlisting>1.315
7.887e77
7.887e-77
.3
0.3
77e5
</programlisting> Lorsque Genius affiche un flottant, il ajoute toujours <computeroutput>.0</computeroutput> même si le nombre est entier. C'est pour rappeler que les nombres à virgule flottante sont considérés comme des quantités imprécises. Lorsqu'un nombre est écrit en utilisant la notation scientifique, c'est toujours un flottant et, par conséquent, Genius n'affiche pas le <computeroutput>.0</computeroutput>.</para>

        <para>
The final type of number in gel is the complex numbers. You can enter a complex number as a sum of real and imaginary parts. To add an imaginary part, append an <literal>i</literal>.  Here are examples of entering complex numbers:
<programlisting>1+2i
8.01i
77*e^(1.3i)
</programlisting>
        </para>

        <important>
          <para>Lorsque vous saisissez des nombres imaginaires, il doit y avoir un nombre devant le <literal>i</literal>. Si vous utilisez <literal>i</literal> tout seul, Genius l'interprète comme une référence à la variable <varname>i</varname>. Si vous avez besoin de faire référence à <literal>i</literal> tout seul, utilisez <literal>1i</literal> à la place.</para>

          <para>Afin de pouvoir utiliser la notation en fraction mixte avec des nombres imaginaires, vous devez mettre la fraction mixte entre parenthèses (par exemple, <userinput>(1 2/5)i</userinput>).</para>
        </important>

      </sect2>


      <sect2 id="genius-gel-values-booleans">
        <title>Booléens</title>
        <para>Genius prend également en charge nativement les données booléennes. Les deux constantes booléennes sont <constant>true</constant> (vrai) et <constant>false</constant> (faux) ; ces identifiants peuvent être utilisés comme n'importe quelle autre variable. Vous pouvez aussi utiliser les identifiants <constant>True</constant>, <constant>TRUE</constant>, <constant>False</constant> et <constant>FALSE</constant> comme alias de ces précédents.</para>
        <para>Là où une expression booléenne est attendue, vous pouvez utiliser une grandeur booléenne ou toute expression qui produit soit un nombre soit un booléen. Si Genius a besoin d'évaluer un nombre en tant que booléen, il interprète 0 comme <constant>false</constant> et tout autre nombre comme <constant>true</constant>.</para>
        <para>Vous pouvez également faire des calculs avec des données booléennes. Par exemple : <programlisting>( (1 + true) - false ) * true
</programlisting> est identique à : <programlisting>( (true or true) or not false ) and true
</programlisting> Seules l'addition, la soustraction et la multiplication sont prises en charge. Si vous mélangez des nombres avec des booléens dans une expression alors les nombres sont convertis en booléens comme indiqué ci-dessus. Cela signifie que, par exemple : <programlisting>1 == true
</programlisting> vaut toujours <constant>true</constant> puisque 1 est converti en <constant>true</constant> avant d'être comparé à <constant>true</constant>.</para>
      </sect2>


      <sect2 id="genius-gel-values-strings">
        <title>Chaînes de caractères</title>
        <para>
Like numbers and Booleans, strings in GEL can be stored as values inside variables and passed to functions. You can also concatenate a string with another value using the plus operator. For example:
<programlisting>a=2+3;"Le résultat est : "+a
</programlisting>
will create the string:
<programlisting>Le résultat est : 5
</programlisting>
You can also use C-like escape sequences such as <literal>\n</literal>,<literal>\t</literal>,<literal>\b</literal>,<literal>\a</literal> and <literal>\r</literal>. To get a <literal>\</literal> or <literal>"</literal> into the string you can quote it with a <literal>\</literal>. For example:
<programlisting>"Barre oblique : \\ Guillemets : \" Tabulations : \t1\t2\t3"
</programlisting>
will make a string:
<programlisting>Barre oblique : \ Guillemets : " Tabulations : 	1	2	3
</programlisting>
Do note however that when a string is returned from a function, escapes are
quoted, so that the output can be used as input.  If you wish to print the
string as it is (without escapes), use the 
<link linkend="gel-function-print"><function>print</function></link>
or
<link linkend="gel-function-printn"><function>printn</function></link> functions.
        </para>
        <para>
		In addition, you can use the library function <link linkend="gel-function-string"><function>string</function></link> to convert anything to a string. For example:
<programlisting>string(22)
</programlisting>
will return
<programlisting>"22"
</programlisting>
Strings can also be compared with <literal>==</literal> (equal), <literal>!=</literal> (not equal) and <literal>&lt;=&gt;</literal> (comparison) operators
        </para>
      </sect2>


      <sect2 id="genius-gel-values-null">
        <title>Null</title>
        <para>
There is a special value called
<constant>null</constant>. No operations can be performed on
it, and nothing is printed when it is returned. Therefore,
<constant>null</constant> is useful when you do not want output from an
expression.  The value <constant>null</constant> can be obtained as an expression when you
type <literal>.</literal>, the constant <constant>null</constant> or nothing.
By nothing we mean that if you end an expression with
a separator <literal>;</literal>, it is equivalent to ending it with a
separator followed by a <constant>null</constant>.
        </para>
        <para>Exemple : <programlisting>x=5;.
x=5;
</programlisting></para>
<para>Certaines fonctions renvoient <constant>null</constant> quand aucune valeur ne peut être renvoyée ou quand une erreur survient. La grandeur <constant>null</constant> est aussi utilisée comme vecteur ou matrice vide ou comme une référence vide.</para>
      </sect2>

    </sect1>

    <sect1 id="genius-gel-variables">
      <title>Utilisation des variables</title>

      <para>Syntaxe : <programlisting>NomDeVariable
</programlisting> Exemple : <screen><prompt>genius&gt; </prompt><userinput>e</userinput>
= 2.71828182846
</screen></para>

      <para>Pour évaluer une variable elle-même, il suffit de saisir le nom de la variable. Cela renvoie la valeur de la variable. Vous pouvez utiliser une variable n'importe où, où vous utiliseriez normalement un nombre ou une chaîne. De plus, les variables sont indispensables pour définir des fonctions qui possèdent des arguments (consultez <xref linkend="genius-gel-functions-defining"/>).</para>

      <tip>
        <title>Utilisation de la complétion à l'aide de la touche Tab</title>
        <para>Vous pouvez utiliser la complétion à l'aide de la touche Tab pour que Genius complète les noms de variable pour vous. Essayez de saisir les premières lettres du nom et appuyez sur la touche <userinput>Tab</userinput>.</para>
      </tip>

      <important>
        <title>Noms de variable sensibles à la casse</title>
        <para>Les noms de variable sont sensibles à la casse. Cela signifie que les variables appelées <varname>bonjour</varname>, <varname>BONJOUR</varname> et <varname>Bonjour</varname> sont toutes différentes.</para>
      </important>


      <sect2 id="genius-gel-variables-setting">
        <title>Attribution de variables</title>
        <para>Syntaxe : <programlisting><![CDATA[<identifier> = <value>
<identifier> := <value>]]>
</programlisting> Exemple: <programlisting>x = 3
x := 3
</programlisting></para>

        <para>
To assign a value to a variable, use the <literal>=</literal> or <literal>:=</literal> operators. These operators set the value of the variable and return the value you set, so you can do things like
<programlisting>a = b = 5
</programlisting>
This will set <varname>b</varname> to 5 and then also set <varname>a</varname> to 5.
        </para>

        <para>Les opérateurs <literal>=</literal> et <literal>:=</literal> peuvent tous les deux être utilisés pour définir des variables. La différence entre les deux est que l'opérateur <literal>:=</literal> agit toujours comme un opérateur d'attribution alors que l'opérateur <literal>=</literal> peut être interprété comme une opération de test d'égalité lorsqu'il est utilisé dans un contexte où une expression booléenne est attendue.</para>

	<para>
	  For more information about the scope of variables, that is when are what variables visible, see <xref linkend="genius-gel-variables-global"/>.
	</para>
      </sect2>

      <sect2 id="genius-gel-variables-built-in">
        <title>Variables internes</title>
        <para>
GEL has a number of built-in ‘variables’, such as
<varname>e</varname>, <varname>pi</varname> or <varname>GoldenRatio</varname>.  These are widely used constants with a preset value, and
they cannot be assigned new values.
There are a number of other built-in variables.
See <xref linkend="genius-gel-function-list-constants"/> for a full list.  Note that <varname>i</varname> is not by default
the square root of negative one (the imaginary number), and is undefined to allow its use as a counter.  If you wish to write the imaginary number you need to
use <userinput>1i</userinput>.
        </para>
      </sect2>


      <sect2 id="genius-gel-previous-result">
        <title>Variable « Résultat précédent »</title>
        <para>Les variables <varname>Ans</varname> et <varname>ans</varname> (answer : réponse) peuvent être utilisées pour obtenir le résultat de la dernière expression. Par exemple, si vous avez fait un calcul, pour ajouter 389 au résultat précédent vous pouvez saisir : <programlisting>Ans+389
</programlisting></para>
      </sect2>
    </sect1>

    <sect1 id="genius-gel-functions">
      <title>Utilisation des fonctions</title>

      <para>Syntaxe : <programlisting>NomDeLaFonction(argument1, argument2, ...)
</programlisting> Exemple : <programlisting>Factorial(5)
cos(2*pi)
gcd(921,317)
</programlisting> Pour évaluer une fonction, saisissez le nom de la fonction, suivi par les arguments de la fonction (s'il y en a) entre parenthèses. Cela renvoie le résultat de l'application de la fonction avec ses arguments. Le nombre d'arguments de la fonction peut, bien sûr, être différent pour chaque fonction.</para>

      <para>
	      There are many built-in functions, such as <link linkend="gel-function-sin"><function>sin</function></link>, <link linkend="gel-function-cos"><function>cos</function></link> and <link linkend="gel-function-tan"><function>tan</function></link>. You can use the <link linkend="gel-command-help"><function>help</function></link> built-in command to get a list of available functions, or see <xref linkend="genius-gel-function-list"/> for a full listing.
      </para>

      <tip>
        <title>Utilisation de la complétion à l'aide de la touche Tab</title>
        <para>Vous pouvez utiliser la fonction de complétion à l'aide de la touche Tab pour que Genius complète les noms de fonction pour vous. Essayez de saisir les quelques premières lettres du nom et appuyez sur <userinput>Tab</userinput>.</para>
      </tip>

      <important>
        <title>Noms de fonction sensibles à la casse</title>
        <para>Les noms des fonctions sont sensibles à la casse. Cela signifie que les fonctions appelées <function>fairecela</function>, <function>FAIRECELA</function> et <function>Fairecela</function> sont toutes différentes.</para>
      </important>


      <sect2 id="genius-gel-functions-defining">
        <title>Définition de fonctions</title>
        <para>Syntaxe : <programlisting><![CDATA[function <identifier>(<comma separated arguments>) = <function body>
<identifier> = (`() = <function body>)
]]></programlisting> Le caractère accent grave <literal>`</literal> indique une fonction anonyme. En l'apposant à un nom de variable, en réalité vous définissez une fonction.</para>

        <para>
A function takes zero or more comma separated arguments, and returns the result of the function body. Defining your own functions is primarily a matter of convenience; one possible use is to have sets of functions defined in GEL files that Genius can load in order to make them available.
Example:
<programlisting>function addup(a,b,c) = a+b+c
</programlisting>
then <userinput>addup(1,4,9)</userinput> yields 14
        </para>
      </sect2>

      <sect2 id="genius-gel-functions-variable-argument-lists">
        <title>Liste d'arguments variable</title>
        <para>Si vous ajoutez <literal>...</literal> après le dernier nom d'argument dans la déclaration de fonction alors Genius permet la transmission d'un nombre quelconque d'arguments à la place de cet argument. Si aucun argument n'est transmis alors cet argument est défini à <constant>null</constant>. Sinon, c'est un vecteur ligne contenant tous les arguments. Par exemple, <programlisting>function f(a,b...) = b
</programlisting> alors <userinput>f(1,2,3)</userinput> donne <computeroutput>[2,3]</computeroutput> tandis que <userinput>f(1)</userinput> donne <constant>null</constant>.</para>
      </sect2>


      <sect2 id="genius-gel-functions-passing-functions">
        <title>Une fonction comme argument d'une autre fonction</title>

        <para>Dans Genius, il est possible de transmettre une fonction comme argument d'une autre fonction. Cela peut être fait en utilisant soit des « nœuds de fonction », soit des fonctions anonymes.</para>

        <para>Si vous ne saisissez pas les parenthèses après un nom de fonction, la fonction est renvoyée sous la forme d'un « nœud de fonction », au lieu d'être évaluée. Le nœud de fonction peut ensuite être transmis à une autre fonction. Par exemple : <programlisting>function f(a,b) = a(b)+1;
function b(x) = x*x;
f(b,2)
</programlisting></para>
        <para>
To pass functions that are not defined,
you can use an anonymous function (see <xref linkend="genius-gel-functions-defining"/>).  That is, you want to pass a function without giving it a name.
Syntax:
<programlisting><![CDATA[function(<comma separated arguments>) = <function body>
`(<comma separated arguments>) = <function body>
]]></programlisting>
Example:
<programlisting>function f(a,b) = a(b)+1;
f(`(x) = x*x,2)
</programlisting>
This will return 5.
        </para>
      </sect2>


    <sect2 id="genius-gel-functions-operations">
      <title>Opérations sur les fonctions</title>
      <para>
	      Some functions allow arithmetic operations, and some single argument functions such as <link linkend="gel-function-exp"><function>exp</function></link> or <link linkend="gel-function-ln"><function>ln</function></link>, to operate on the function. For example,
<programlisting>exp(sin*cos+4)
</programlisting>
will return a function that takes <varname>x</varname> and returns <userinput>exp(sin(x)*cos(x)+4)</userinput>.  It is functionally equivalent
to typing
<programlisting>`(x) = exp(sin(x)*cos(x)+4)
</programlisting>

This operation can be useful when quickly defining functions. For example to create a function called <varname>f</varname>
to perform the above operation, you can just type:
<programlisting>f = exp(sin*cos+4)
</programlisting>
It can also be used in plotting. For example, to plot sin squared you can enter:
<programlisting>LinePlot(sin^2)
</programlisting>
      </para>

      <warning>
        <para>Toutes les fonctions ne peuvent pas être utilisées de cette façon. Par exemple, lorsque vous utilisez une opération binaire, les fonctions doivent prendre le même nombre d'arguments.</para>
      </warning>
    </sect2>


    </sect1>

    <sect1 id="genius-gel-separator">
      <title>Séparateur</title>
      <para>
	      GEL is somewhat different from other languages in how it deals with multiple commands and functions.
	      In GEL you must chain commands together with a separator operator.
That is, if you want to type more than one expression you have to use
the <literal>;</literal> operator in between the expressions.   This is
a way in which both expressions are evaluated and the result of the second one (or the last one
if there is more than two expressions) is returned.
Suppose you type the following:
<programlisting>3 ; 5
</programlisting>
This expression will yield 5.
      </para>
      <para>
This will require some parenthesizing to make it unambiguous sometimes,
especially if the <literal>;</literal> is not the top most primitive. This slightly differs from
other programming languages where the <literal>;</literal> is a terminator of statements, whereas
in GEL it’s actually a binary operator. If you are familiar with pascal
this should be second nature. However genius can let you pretend it is a
terminator to some degree.  If a <literal>;</literal> is found at the end of a parenthesis or a block,
genius will append a null to it as if you would have written
<userinput>;null</userinput>.
This is useful in case you do not want to return a value from say a loop,
or if you handle the return differently. Note that it will slightly slow down
the code if it is executed too often as there is one more operator involved.
      </para>
      <para>
	      If you are typing expressions in a program you do not have to add a semicolon.  In this case
	      genius will simply print the return value whenever it executes the expression.  However, do note that if you are defining a
	      function, the body of the function is a single expression.
      </para>
    </sect1>

    <sect1 id="genius-gel-comments">
      <title>Commentaires</title>
      <para>
	      GEL is similar to other scripting languages in that <literal>#</literal> denotes
	      a comments, that is text that is not meant to be evaluated.  Everything beyond the
	      pound sign till the end of line will just be ignored.  For example,
<programlisting># This is just a comment
# every line in a comment must have its own pond sign
# in the next line we set x to the value 123
x=123;
</programlisting>
      </para>
    </sect1>

    <sect1 id="genius-gel-modular-evaluation">
      <title>Évaluation modulaire</title>
      <para>
	      Genius implements modular arithmetic.
To use it you just add "mod &lt;integer&gt;" after
the expression.  Example:
<userinput>2^(5!) * 3^(6!) mod 5</userinput>
It could be possible to do modular arithmetic by computing with integers and then modding in the end with
the <literal>%</literal> operator, which simply gives the remainder, but
that may be time consuming if not impossible when working with larger numbers.
For example, <userinput>10^(10^10) % 6</userinput> will simply not work (the exponent
will be too large), while
<userinput>10^(10^10) mod 6</userinput> is instantaneous.  The first expression first tries to compute the integer
<userinput>10^(10^10)</userinput> and then find remainder after division by 6, while the second expression evaluates
everything modulo 6 to begin with.
      </para>
      <para>Vous pouvez calculer l'inverse de nombres modulo des entiers juste en utilisant des nombres rationnels (bien sûr, l'inverse doit exister). Exemples : <programlisting>10^-1 mod 101
1/10 mod 101</programlisting> Vous pouvez aussi faire de l'évaluation modulaire avec des matrices y compris prendre l'inverse, mettre à la puissance ou multiplier. Exemple : <programlisting>A = [1,2;3,4]
B = A^-1 mod 5
A*B mod 5</programlisting> Cela doit donner la matrice identité car B est l'inverse de A modulo 5.</para>
      <para>Certaines fonctions telles que <link linkend="gel-function-sqrt"><function>sqrt</function></link> ou <link linkend="gel-function-log"><function>log</function></link> fonctionnent différemment en mode modulaire. Elles vont alors fonctionner comme leur version discrète travaillant avec l'ensemble des entiers que vous avez sélectionnés, par exemple, <programlisting>genius&gt; sqrt(4) mod 7
=
[2, 5]
genius&gt; 2*2 mod 7
= 4</programlisting>La fonction <function>sqrt</function> renvoie en fait toutes les racines carrées possibles.</para>
      <para>
	      Do not chain mod operators, simply place it at the end of the computation, all computations in the expression on the left
	      will be carried out in mod arithmetic.  If you place a mod inside
	      a mod, you will get unexpected results.  If you simply want to
	      mod a single number and control exactly when remainders are
	      taken, best to use the <literal>%</literal> operator.  When you
	      need to chain several expressions in modular arithmetic with
	      different divisors, it may be best to just split up the expression into several and use
	      temporary variables to avoid a mod inside a mod.
      </para>
    </sect1>

    <sect1 id="genius-gel-operator-list">
      <title>Liste des opérateurs GEL</title>

      <para>Dans le langage GEL, chaque chose est vraiment une expression. Les expressions sont reliées ensemble par différents opérateurs. Comme nous l'avons vu, même le séparateur est juste un opérateur binaire GEL. Voici une liste des opérateurs GEL.</para>

      <variablelist>
        <varlistentry>
         <term><userinput>a;b</userinput></term>
         <listitem>
           <para>C'est le séparateur, il évalue simplement à la fois <varname>a</varname> et <varname>b</varname> mais ne renvoie que le résultat de <varname>b</varname>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a=b</userinput></term>
         <listitem>
           <para>L'opérateur d'attribution. Il attribue <varname>b</varname> à <varname>a</varname> (<varname>a</varname> doit être une <link linkend="genius-gel-lvalues">valeur à gauche</link> valide). Remarquez que cet opérateur peut être transformé en <literal>==</literal> s'il est utilisé là où une expression booléenne est attendue.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a:=b</userinput></term>
         <listitem>
           <para>L'opérateur d'attribution. Il attribue <varname>b</varname> à <varname>a</varname> (<varname>a</varname> doit être une <link linkend="genius-gel-lvalues">valeur à gauche</link> valide). Il est différent de <literal>=</literal> car il n'est jamais transformée en <literal>==</literal>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>|a|</userinput></term>
         <listitem>
           <para>
		   Absolute value.
		   In case the expression is a complex number the result will be the modulus
(distance from the origin).  For example:
<userinput>|3 * e^(1i*pi)|</userinput>
returns 3.
	  </para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/AbsoluteValue.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a^b</userinput></term>
         <listitem>
           <para>Exposant, met <varname>a</varname> à la puissance <varname>b</varname>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a.^b</userinput></term>
         <listitem>
           <para>Exposant élément par élément. Met chaque élément d'une matrice <varname>a</varname> à la puissance <varname>b</varname>. Si <varname>b</varname> est une matrice de la même taille que <varname>a</varname> alors l'opération se réalise élément par élément. Si <varname>a</varname> est un nombre et <varname>b</varname> est une matrice alors cela crée une matrice de la même taille que <varname>b</varname> contenant <varname>a</varname> mis à la puissance de chaque élément de <varname>b</varname>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a+b</userinput></term>
         <listitem>
           <para>
             Addition.  Adds two numbers, matrices, functions or strings.  If
	     you add a string to anything the result will just be a string.  If one is
	     a square matrix and the other a number, then the number is multiplied by
	     the identity matrix.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a-b</userinput></term>
         <listitem>
           <para>Soustraction. Soustrait deux nombres, matrices ou fonctions.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a*b</userinput></term>
         <listitem>
           <para>Multiplication. C'est la multiplication matricielle normale.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a.*b</userinput></term>
         <listitem>
           <para>Multiplication élément par élément si <varname>a</varname> et <varname>b</varname> sont des matrices.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a/b</userinput></term>
         <listitem>
           <para>
		   Division.  When <varname>a</varname> and <varname>b</varname> are just numbers
		   this is the normal division.  When they are matrices, then this is
		   equivalent to <userinput>a*b^-1</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a./b</userinput></term>
         <listitem>
           <para>
		   Element by element division.  Same as <userinput>a/b</userinput> for
		   numbers, but operates element by element on matrices.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a\b</userinput></term>
         <listitem>
           <para>Division arrière. C'est donc la même chose que <userinput>b/a</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a.\b</userinput></term>
         <listitem>
           <para>Division arrière élément par élément.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a%b</userinput></term>
         <listitem>
           <para>L'opérateur modulo. Cela n'active pas le mode d'<link linkend="genius-gel-modular-evaluation">évaluation modulaire</link>, mais renvoie juste le reste de <userinput>a/b</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a.%b</userinput></term>
         <listitem>
           <para>L'opérateur modulo élément par élément. Renvoie le reste après la division entière élément par élément de <userinput>a./b</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a mod b</userinput></term>
         <listitem>
           <para>Opérateur d'évaluation modulaire. L'expression <varname>a</varname> est évaluée modulo <varname>b</varname>. Consultez <xref linkend="genius-gel-modular-evaluation"/>. Certaines fonctions et opérateurs se comportent différemment modulo un entier.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a!</userinput></term>
         <listitem>
           <para>Opérateur factoriel. Il s'agit de <userinput>1*...*(n-2)*(n-1)*n</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a!!</userinput></term>
         <listitem>
           <para>Opérateur double factoriel. Il s'agit de <userinput>1*...*(n-4)*(n-2)*n</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a==b</userinput></term>
         <listitem>
           <para>
	     Equality operator.
	     Returns <constant>true</constant> or <constant>false</constant>
	     depending on <varname>a</varname> and <varname>b</varname> being equal or not.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a!=b</userinput></term>
         <listitem>
           <para>Opérateur inégalité, renvoie <constant>true</constant> si <varname>a</varname> n'est pas égal à <varname>b</varname> sinon renvoie <constant>false</constant>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a&lt;&gt;b</userinput></term>
         <listitem>
           <para>Autre opérateur inégalité, renvoie <constant>true</constant> si <varname>a</varname> n'est pas égal à <varname>b</varname> sinon renvoie <constant>false</constant>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a&lt;=b</userinput></term>
         <listitem>
           <para>
             Less than or equal operator,
	     returns <constant>true</constant> if <varname>a</varname> is
	     less than or equal to 
	     <varname>b</varname> else returns <constant>false</constant>.
	     These can be chained as in <userinput>a &lt;= b &lt;= c</userinput> (can
	     also be combined with the less than operator).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a&gt;=b</userinput></term>
         <listitem>
           <para>
             Greater than or equal operator,
	     returns <constant>true</constant> if <varname>a</varname> is
	     greater than or equal to 
	     <varname>b</varname> else returns <constant>false</constant>.
	     These can be chained as in <userinput>a &gt;= b &gt;= c</userinput>
	     (can also be combine with the greater than operator).
           </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><userinput>a&lt;b</userinput></term>
         <listitem>
           <para>
             Less than operator,
	     returns <constant>true</constant> if <varname>a</varname> is
	     less than 
	     <varname>b</varname> else returns <constant>false</constant>.
	     These can be chained as in <userinput>a &lt; b &lt; c</userinput>
	     (can also be combine with the less than or equal to operator).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a&gt;b</userinput></term>
         <listitem>
           <para>
             Greater than operator,
	     returns <constant>true</constant> if <varname>a</varname> is
	     greater than 
	     <varname>b</varname> else returns <constant>false</constant>.
	     These can be chained as in <userinput>a &gt; b &gt; c</userinput>
	     (can also be combine with the greater than or equal to operator).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a&lt;=&gt;b</userinput></term>
         <listitem>
           <para>Opérateur comparaison. Si <varname>a</varname> est égal à <varname>b</varname>, cela renvoie 0, si <varname>a</varname> est inférieur à <varname>b</varname>, cela renvoie -1 et si <varname>a </varname> est supérieur à <varname>b</varname>, cela renvoie 1.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a and b</userinput></term>
         <listitem>
           <para>
		   Logical and.  Returns true if both
		   <varname>a</varname> and <varname>b</varname> are true,
		   else returns false.  If given numbers, nonzero numbers
		   are treated as true.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a or b</userinput></term>
         <listitem>
           <para>
             Logical or.
	     Returns true if both
	     <varname>a</varname> or <varname>b</varname> are true,
	     else returns false.  If given numbers, nonzero numbers
	     are treated as true.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a xor b</userinput></term>
         <listitem>
           <para>
             Logical xor.
	     Returns true exactly one of
	     <varname>a</varname> or <varname>b</varname> is true,
	     else returns false.  If given numbers, nonzero numbers
	     are treated as true.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>not a</userinput></term>
         <listitem>
           <para>
		   Logical not.  Returns the logical negation of <varname>a</varname>
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>-a</userinput></term>
         <listitem>
           <para>
             Negation operator.  Returns the negative of a number or a matrix (works element-wise on a matrix).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>&amp;a</userinput></term>
         <listitem>
           <para>
             Variable referencing (to pass a reference to a variable).
	     See <xref linkend="genius-gel-references"/>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>*a</userinput></term>
         <listitem>
           <para>
             Variable dereferencing (to access a referenced variable).
	     See <xref linkend="genius-gel-references"/>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a'</userinput></term>
         <listitem>
           <para>
		   Matrix conjugate transpose.  That is, rows and columns get swapped and we take complex conjugate of all entries.  That is
		   if the i,j element of <varname>a</varname> is x+iy, then the j,i element of <userinput>a'</userinput> is x-iy.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a.'</userinput></term>
         <listitem>
           <para>
             Matrix transpose, does not conjugate the entries.  That is, 
	     the i,j element of <varname>a</varname>  becomes the j,i element of <userinput>a.'</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a@(b,c)</userinput></term>
         <listitem>
           <para>Renvoie l'élément ligne <varname>b</varname> et colonne <varname>c</varname> d'une matrice. Si <varname>b</varname> et <varname>c</varname> sont des vecteurs alors cela renvoie les lignes et les colonnes correspondantes, soit une sous-matrice.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a@(b,)</userinput></term>
         <listitem>
           <para>Renvoie une ligne de matrice (ou plusieurs lignes si <varname>b</varname> est un vecteur).</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a@(b,:)</userinput></term>
         <listitem>
           <para>Comme ci-dessus.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a@(,c)</userinput></term>
         <listitem>
           <para>Renvoie une colonne de matrice (ou des colonnes si <varname>c</varname> est un vecteur).</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a@(:,c)</userinput></term>
         <listitem>
           <para>Comme ci-dessus.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a@(b)</userinput></term>
         <listitem>
           <para>Renvoie un élément d'une matrice en le traitant comme un vecteur. Cela parcourt la matrice dans le sens des lignes.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a:b</userinput></term>
         <listitem>
           <para>Construit un vecteur allant de <varname>a</varname> à <varname>b</varname> (ou indique une région ligne, colonne pour l'opérateur <literal>@</literal>). Par exemple pour obtenir les lignes 2 à 4 de la matrice <varname>A</varname>, nous pourrions faire <programlisting>A@(2:4,)
	     </programlisting> puisque <userinput>2:4</userinput> renvoie un vecteur <userinput>[2,3,4]</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>a:b:c</userinput></term>
         <listitem>
           <para>Construit un vecteur allant de <varname>a</varname> à <varname>c</varname> avec un pas de <varname>b</varname>. Ce qui donne par exemple <programlisting>genius&gt; 1:2:9
=
`[1, 3, 5, 7, 9]
</programlisting></para>
	   <para>
	     When the numbers involved are floating point numbers, for example
	     <userinput>1.0:0.4:3.0</userinput>, the output is what is expected
	     even though adding 0.4 to 1.0 five times is actually just slightly
	     more than 3.0 due to the way that floating point numbers are
	     stored in base 2 (there is no 0.4, the actual number stored is
	     just ever so slightly bigger).  The way this is handled is the
	     same as in the for, sum, and prod loops.  If the end is within
	     <userinput>2^-20</userinput> times the step size of the endpoint,
	     the endpoint is used and we assume there were roundoff errors.
	     This is not perfect, but it handles the majority of the cases.
	     This check is done only from version 1.0.18 onwards, so execution
	     of your code may differ on older versions.  If you want to avoid
	     dealing with this issue, use actual rational numbers, possibly
	     using the <function>float</function> if you wish to get floating
	     point numbers in the end.  For example
	     <userinput>1:2/5:3</userinput> does the right thing and
	     <userinput>float(1:2/5:3)</userinput> even gives you floating
	     point numbers and is ever so slightly more precise than
	     <userinput>1.0:0.4:3.0</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>(a)i</userinput></term>
         <listitem>
           <para>Crée un nombre imaginaire (multiplie <varname>a</varname> par le nombre imaginaire pur). Remarquez que normalement le nombre <varname>i</varname> s'écrit <userinput>1i</userinput>. Donc le nombre ci-dessus est égal à <programlisting>(a)*1i
	     </programlisting></para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><userinput>`a</userinput></term>
         <listitem>
           <para>Apostropher un identifiant afin qu'il ne soit pas évalué. Ou apostropher une matrice afin qu'elle ne soit pas étendue.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><userinput>a swapwith b</userinput></term>
         <listitem>
           <para>Échange la valeur de <varname>a</varname> par la valeur de <varname>b</varname>. Pour le moment, ne fonctionne pas sur des ensembles d'éléments de matrice. Renvoie <constant>null</constant>. Disponible à partir de la version 1.0.13.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><userinput>increment a</userinput></term>
         <listitem>
           <para>Incrémente la variable <varname>a</varname> de 1. Si <varname>a</varname> est une matrice alors incrémente chaque élément. C'est équivalent à <userinput>a=a+1</userinput> mais est plus rapide. Renvoie <constant>null</constant>. Disponible à partir de la version 1.0.13.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><userinput>increment a by b</userinput></term>
         <listitem>
           <para>Incrémente la variable <varname>a</varname> de <varname>b</varname>. Si <varname>a</varname> est une matrice alors incrémente chaque élément. C'est équivalent à <userinput>a=a+b</userinput> mais est plus rapide. Renvoie <constant>null</constant>. Disponible à partir de la version 1.0.13.</para>
         </listitem>
        </varlistentry>


      </variablelist>

<note>
<para>L'opérateur @() rend l'opérateur : très utile. Grâce à lui, vous pouvez indiquer des régions d'une matrice. Ainsi a@(2:4,6) sont les lignes 2,3,4 de la colonne 6 ou a@(,1:2) vous renvoie les deux premières colonnes d'une matrice. Vous pouvez également attribuer un opérateur @() tant que la valeur de droite est une matrice qui correspond en taille à la région ou si c'est n'importe quel autre type de valeur.</para>
</note>

<note>
<para>
The comparison operators (except for the &lt;=&gt; operator, which behaves normally), are not strictly binary operators, they can in fact be grouped in the normal mathematical way, e.g.: (1&lt;x&lt;=y&lt;5) is a legal boolean expression and means just what it should, that is (1&lt;x and x≤y and y&lt;5)
</para>
</note>

<note>
<para>L'opérateur unitaire « moins » agit de manière différente en fonction de l'endroit où il apparaît. S'il apparaît devant un nombre, il est très prioritaire, s'il apparaît devant une expression, il est moins prioritaire que les opérateurs puissance et factoriel. Par exemple, <userinput>-1^k</userinput> est bien <userinput>(-1)^k</userinput>, mais <userinput>-foo(1)^k</userinput> est bien <userinput>-(foo(1)^k)</userinput>. En conséquence, faites attention à son utilisation et, en cas de doute, ajoutez des parenthèses.</para>
</note>
    </sect1>

  </chapter>

  <!-- ============= GEL Programming ========================== -->
  <chapter id="genius-gel-programming">
    <title>Programmation avec GEL</title>

    <sect1 id="genius-gel-conditionals">
      <title>Tests</title>
      <para>Syntaxe : <programlisting><![CDATA[if <expression1> then <expression2> [else <expression3>]
]]></programlisting> Si <literal>else</literal> est omis alors si l'<literal>expression1</literal> donne <constant>false</constant> ou 0, <literal>NULL</literal> est renvoyé.</para>
      <para>Exemples : <programlisting><![CDATA[if(a==5)then(a=a-1)
if b<a then b=a
if c>0 then c=c-1 else c=0
a = ( if b>0 then b else 1 )
]]></programlisting> Notez que <literal>=</literal> est traduit en <literal>==</literal> s'il est utilisé à l'intérieur de l'expression du <literal>if</literal>, donc <programlisting>if a=5 then a=a-1
</programlisting> est interprété comme : <programlisting>if a==5 then a:=a-1
</programlisting></para>
    </sect1>

    <sect1 id="genius-gel-loops">
      <title>Boucles</title>

      <sect2 id="genius-gel-loops-while">
        <title>Boucles tant que (while) et jusqu'à (until)</title>
        <para>Syntaxe : <programlisting><![CDATA[while <expression1> do <expression2>
until <expression1> do <expression2>
do <expression2> while <expression1>
do <expression2> until <expression1>]]></programlisting> Elles sont similaires à celles rencontrées dans les autres langages. Cependant puisqu'en GEL, cela doit être une expression qui doit renvoyer des valeurs, ces constructions renvoient simplement le résultat de la dernière itération ou <literal>NULL</literal> si aucune itération n'a eu lieu. Dans l'expression booléenne, <literal>=</literal> est traduit en <literal>==</literal> de la même manière que cela se produit pour l'instruction <literal>if</literal>.</para>
      </sect2>

      <sect2 id="genius-gel-loops-for">
        <title>Boucles pour (for)</title>
        <para>Syntaxe : <programlisting><![CDATA[for <identifier> = <from> to <to> do <body>
for <identifier> = <from> to <to> by <increment> do <body>]]></programlisting> Boucle où l'identifiant (identifier) prend toutes les valeurs comprises entre <literal>&lt;from&gt;</literal> et <literal>&lt;to&gt;</literal>, avec en option un incrément autre que 1. Elles sont plus rapides, plus simples à utiliser et plus compactes que les boucles classiques ci-dessus mais moins flexibles. L'identifiant doit être un identifiant et ne peut pas être un déréférencement. La valeur de l'identifiant est la dernière valeur prise par l'identifiant ou <literal>&lt;from&gt;</literal> si le contenu (body) de la boucle n'a jamais été évalué. Vous êtes sûr que la variable est initialisée après une boucle donc vous pouvez l'utiliser sans risque. <literal>&lt;from&gt;</literal>, <literal>&lt;to&gt;</literal> et <literal>&lt;increment&gt;</literal> ne doivent pas être complexes. Il n'est pas sûr que la valeur <literal>&lt;to&gt;</literal> soit atteinte, mais elle n'est jamais dépassée. Par exemple, ce qui suit affiche les nombres impairs de 1 à 19 : <programlisting>for i = 1 to 20 by 2 do print(i)
</programlisting></para>
        <para>
		When one of the values is a floating point number, then the
		final check is done to within 2^-20 of the step size.  That is,
		even if we overshoot by 2^-20 times the "by" above, we still execute the last
		iteration.  This way 
<programlisting>for x = 0 to 1 by 0.1 do print(x)
</programlisting>
does the expected even though adding 0.1 ten times becomes just slightly more 1.0 due to the way that floating point numbers
are stored in base 2 (there is no 0.1, the actual number stored is just ever so slightly bigger).  This is not perfect but it handles
the majority of the cases.  If you want to avoid dealing with this issue, use actual rational numbers for example:
<programlisting>for x = 0 to 1 by 1/10 do print(x)
</programlisting>
		This check is done only from version 1.0.16 onwards, so execution of your code may differ on older versions.
	</para>
      </sect2>

      <sect2 id="genius-gel-loops-foreach">
        <title>Boucles pour chaque (foreach)</title>
        <para>
Syntax:
<programlisting><![CDATA[for <identifier> in <matrix> do <body>]]></programlisting>

			For each element in the matrix, going row by row from left to right we execute the body
		       with the identifier set to the current element. To
print numbers 1,2,3 and 4 in this order you could do:
<programlisting>for n in [1,2:3,4] do print(n)
</programlisting>
If you wish to run through the rows and columns of a matrix, you can use
the RowsOf and ColumnsOf functions, which return a vector of the rows or
columns of the matrix.  So,
<programlisting>for n in RowsOf ([1,2:3,4]) do print(n)
</programlisting>
will print out [1,2] and then [3,4].
        </para>
      </sect2>

      <sect2 id="genius-gel-loops-break-continue">
        <title>Instructions « break » et « continue »</title>
        <para>Vous pouvez aussi utiliser les instructions <literal>break</literal> et <literal>continue</literal> dans les boucles. L'instruction <literal>continue</literal> reprend la boucle à sa prochaine itération alors que l'instruction <literal>break</literal> sort de la boucle actuelle. <programlisting><![CDATA[while(<expression1>) do (
  if(<expression2>) break
  else if(<expression3>) continue;
  <expression4>
)
]]></programlisting></para>
      </sect2>
    </sect1>

    <sect1 id="genius-gel-sums-products">
      <title>Sommes et produits</title>
      <para>Syntaxe : <programlisting><![CDATA[sum <identifier> = <from> to <to> do <body>
sum <identifier> = <from> to <to> by <increment> do <body>
sum <identifier> in <matrix> do <body>
prod <identifier> = <from> to <to> do <body>
prod <identifier> = <from> to <to> by <increment> do <body>
prod <identifier> in <matrix> do <body>]]></programlisting> Si vous remplacez <literal>for</literal> par <literal>sum</literal> ou <literal>prod</literal> alors vous obtenez une somme ou un produit à la place d'une boucle <literal>for</literal>. Au lieu de renvoyer la dernière valeur, cela renvoie la somme ou le produit des valeurs respectivement.</para>
      <para>Si aucun contenu (body) est exécuté (par exemple, <userinput>sum i=1 to 0 do ...</userinput>) alors la convention standard est que <literal>sum</literal> renvoie 0 et <literal>prod</literal> renvoie 1.</para>
      <para>
	      For floating point numbers the same roundoff error protection is done as in the for loop.
	     See <xref linkend="genius-gel-loops-for"/>.
      </para>
    </sect1>

    <sect1 id="genius-gel-comparison-operators">
      <title>Opérateurs de comparaison</title>
      <para>Les opérateurs de comparaison standard suivants sont pris en charge dans GEL et ont des significations évidentes : <literal>==</literal>, <literal>&gt;=</literal>, <literal>&lt;=</literal>, <literal>!=</literal>, <literal>&lt;&gt;</literal>, <literal>&lt;</literal>, <literal>&gt;</literal>. Ils renvoient <constant>true</constant> ou <constant>false</constant>. Les opérateurs <literal>!=</literal> et <literal>&lt;&gt;</literal> sont les mêmes et signifient « n'est pas égal à ». GEL comprend également l'opérateur <literal>&lt;=&gt;</literal> qui renvoie -1 si la partie de gauche est plus petite, 0 si les deux parties sont égales, 1 si la partie de gauche est plus grande.</para>

      <para>Normalement <literal>=</literal> est traduit en <literal>==</literal> partout où GEL s'attend à une condition comme celle de la condition si (if). Par exemple, <programlisting>if a=b then c
if a==b then c
</programlisting> sont identiques en GEL. Cependant vous devriez vraiment utiliser <literal>==</literal> ou <literal>:=</literal> lorsque vous voulez respectivement comparer ou attribuer si vous voulez éviter des erreurs et que votre code soit facile à lire.</para>

      <para>
	All the comparison operators (except for the
	<literal>&lt;=&gt;</literal> operator, which
	behaves normally), are not strictly binary operators, they can in fact
	be grouped in the normal mathematical way, e.g.:
	(<literal>1&lt;x&lt;=y&lt;5</literal>) is
	a legal boolean expression and means just what it should, that is
	(1&lt;x and x≤y and y&lt;5)
      </para>
      <para>Pour construire des expressions logiques, utilisez les mots <literal>not</literal>, <literal>and</literal>, <literal>or</literal>, <literal>xor</literal>. Les opérateurs <literal>or</literal> et <literal>and</literal> sont des entités spéciales car ils évaluent leurs arguments les uns après les autres, donc les astuces classiques des évaluations conditionnelles fonctionnent. Par exemple : <literal>1 or a=1</literal> n'effectue pas l'attribution <literal>a=1</literal> puisque le premier argument est vrai (true).</para>
    </sect1>

      <sect1 id="genius-gel-variables-global">
        <title>Variables globales et portée des variables</title>
	<para>GEL est un <ulink url="http://fr.wikipedia.org/wiki/Port%C3%A9e_%28informatique%29">langage à portée dynamique</ulink>. Nous allons expliquer ce que cela signifie ci-dessous. Les variables et les fonctions normales sont à portée dynamique. Les exceptions sont les <link linkend="genius-gel-parameters">variables paramètres</link> qui sont toujours globales.</para>
	<para>Comme la plupart des langages de programmation, GEL possède différents types de variables. Normalement lorsqu'une variable est définie dans une fonction, elle est visible dans cette fonction et à partir de toutes les fonctions qui sont appelées (tous les contextes supérieurs). Par exemple, supposons qu'une fonction <function>f</function> définit une variable <varname>a</varname> puis appelle la fonction <function>g</function>. Alors la fonction <function>g</function> peut faire référence à <varname>a</varname>. Mais dès que la fonction <function>f</function> est quittée, la variable <varname>a</varname> disparaît de la portée. Par exemple, le code suivant affiche 5. La fonction <function>g</function> ne peut pas être appelée à partir du niveau supérieur (en dehors de <function>f</function> puisque <varname>a</varname> n'est pas défini). <programlisting>function f() = (a:=5; g());
function g() = print(a);
f();
</programlisting></para>
        <para>Si vous définissez une variable à l'intérieur d'une fonction, elle va supplanter toutes variables définies dans les fonctions appelantes. Par exemple, si nous modifions le code ci-dessus et écrivons : <programlisting>function f() = (a:=5; g());
function g() = print(a);
a:=10;
f();
</programlisting> Ce code affiche toujours 5. Mais si vous appelez <function>g</function> à l'extérieur de <function>f</function> alors la valeur 10 s'affiche. Remarquez que le fait d'initialiser <varname>a</varname> à 5 à l'intérieur de <function>f</function> ne modifie pas la valeur de <varname>a</varname> au niveau (global) supérieur donc si vous contrôlez maintenant la valeur de <varname>a</varname>, elle sera toujours de 10.</para>
	<para>Les arguments de fonction sont exactement comme les variables définies à l'intérieur de la fonction sauf qu'ils sont initialisés à la valeur qui a été transmise à la fonction. En dehors de ce point, ils sont traités exactement comme toutes les autres variables définies dans la fonction.</para>
	<para>Les fonctions sont traitées exactement comme les variables. Par conséquent, vous pouvez redéfinir localement les fonctions. Normalement (au niveau supérieur) vous ne pouvez pas redéfinir des variables et fonctions protégées mais, vous pouvez le faire localement. Considérons la session suivante : <screen><prompt>genius&gt; </prompt><userinput>function f(x) = sin(x)^2</userinput>
= (`(x)=(sin(x)^2))
<prompt>genius&gt; </prompt><userinput>function g(x) = ((function sin(x)=x^10);f(x))</userinput>
= (`(x)=((sin:=(`(x)=(x^10)));f(x)))
<prompt>genius&gt; </prompt><userinput>g(10)</userinput>
= 1e20
</screen></para>
	<para>
	  Functions and variables defined at the top level are
	  considered global.  They are visible from anywhere.  As we
	  said the following function <function>f</function>
	  will not change the value of <varname>a</varname> to 5.
<programlisting>a=6;
function f() = (a:=5);
f();
</programlisting>
	  Sometimes, however, it is necessary to set
a global variable from inside a function.  When this behavior is needed,
use the
<link linkend="gel-function-set"><function>set</function></link> function. Passing a string or a quoted identifier to
this function sets the variable globally (on the top level).
For example, to set
<varname>a</varname> to the value 3 you could call:
<programlisting>set(`a,3)
</programlisting>
or:
<programlisting>set("a",3)
</programlisting>
        </para>
        <para>La fonction <function>set</function> définit toujours au niveau global supérieur. Il n'est pas possible de définir une variable locale dans des fonctions à partir d'un sous-programme. Si c'est nécessaire, vous devez utiliser la transmission par référence.</para>
	<para>
		See also the
		<link linkend="gel-function-SetElement"><function>SetElement</function></link> and
		<link linkend="gel-function-SetVElement"><function>SetVElement</function></link> functions.
	</para>
	<para>Donc pour récapituler dans un langage plus technique : genius opère avec différents contextes numérotés. Le niveau supérieur est le contexte 0 (zéro). À chaque fois qu'une fonction est entrée, le contexte est augmenté et lorsqu'une fonction est quittée, le contexte est diminué. Une fonction ou une variable est toujours visible à partir de tous les contextes de numéro plus élevé. Si une variable a été définie dans un contexte de numéro plus bas alors attribuer une valeur à cette variable a pour effet de créer une nouvelle variable locale dans le numéro de contexte actuel et cette variable est maintenant visible de tous les contextes de numéro plus élevé.</para>
	<para>
	  There are also true local variables that are not seen from
	  anywhere but the current context.  Also when returning functions
	  by value it may reference variables not visible from higher context
	  and this may be a problem.  See the sections
	  <link linkend="genius-gel-true-local-variables">True
	  Local Variables</link> and
	  <link linkend="genius-gel-returning-functions">Returning
	  Functions</link>.
	</para>
      </sect1>

      <sect1 id="genius-gel-parameters">
        <title>Variables paramètres</title>
	<para>Comme dit précédemment, il existe des variables spéciales appelées paramètres qui existent dans toutes les portées. Pour déclarer un paramètre appelé <varname>foo</varname> et initialisé à 1, écrivez <programlisting><![CDATA[parameter foo = 1
]]></programlisting> À partir de cet instant, <varname>foo</varname> est une variable complètement globale. Attribuer une valeur à <varname>foo</varname> à l'intérieur d'une fonction, modifie la variable dans tous les contextes, ce qui signifie que les fonctions ne possèdent pas de copie privée des paramètres.</para>
        <para>Si vous annulez la définition comme paramètre en utilisant la fonction <link linkend="gel-function-undefine"><function>undefine</function></link>, la variable cesse d'être un paramètre.</para>
        <para>
	  Some parameters are built-in and modify the behavior of genius.
        </para>
      </sect1>

    <sect1 id="genius-gel-returning">
      <title>Sortie de fonction</title>
	<para>Normalement une fonction est une ou plusieurs expressions séparées par un point virgule et la valeur de la dernière expression est renvoyée. C'est suffisant pour les fonctions simples mais parfois vous ne voulez pas qu'une fonction renvoie la dernière chose calculée. Il se peut que vous vouliez, par exemple, quitter la fonction à partir du milieu de la fonction. Dans ce cas, vous pouvez utiliser le mot-clé <literal>return</literal>. <literal>Return</literal> prend un seul argument qui est la valeur renvoyée.</para>
      <para>Exemple : <programlisting><![CDATA[function f(x) = (
  y=1;
  while true do (
    if x>50 then return y;
    y=y+1;
    x=x+1
  )
)
]]></programlisting></para>
    </sect1>


    <sect1 id="genius-gel-references">
      <title>Références</title>
      <para>Il peut être nécessaire pour certaines fonctions de renvoyer plus d'une seule valeur. C'est possible en renvoyant un vecteur de valeurs mais souvent il est pratique d'utiliser le passage d'une référence à une variable. Vous transmettez une référence vers une variable à une fonction et la fonction attribue des valeurs à la variable pour vous en utilisant un déréférencement. Ce n'est pas le seul usage que vous pouvez faire du passage par référence mais c'est son utilisation principale.</para>
      <para>Lorsque vous utilisez des fonctions qui renvoient des valeurs à travers des références dans sa liste d'argument, il suffit de transmettre le nom de la variable précédée d'une esperluette. Par exemple, le code suivant calcule une valeur propre d'une matrice <varname>A</varname> avec un vecteur propre initial pressenti <varname>x</varname> et enregistre le vecteur propre calculé dans la variable appelée <varname>v</varname> : <programlisting><![CDATA[RayleighQuotientIteration (A,x,0.001,100,&v)
]]></programlisting></para>
      <para>Les détails concernant le fonctionnement des références et leur syntaxe sont similaires à ceux du langage C. L'opérateur <literal>&amp;</literal> référence une variable et <literal>*</literal> la déréférence. Les deux ne peuvent s'appliquer que sur un identifiant, par conséquent <literal>**a</literal> n'est pas une expression légale en GEL.</para>
      <para>Les références s'expliquent mieux par un exemple : <programlisting><![CDATA[a=1;
b=&a;
*b=2;
]]></programlisting> Maintenant <varname>a</varname> contient 2. Vous pouvez également référencer des fonctions : <programlisting><![CDATA[function f(x) = x+1;
t=&f;
*t(3)
]]></programlisting> donne 4.</para>
    </sect1>

    <sect1 id="genius-gel-lvalues">
      <title>Valeurs à gauche (lvalues)</title>
      <para>Une valeur à gauche est la partie à gauche d'une attribution. En d'autres mots, une valeur à gauche est la chose dans laquelle vous attribuez quelque chose. Des valeurs à gauche valides sont : <variablelist>
  <varlistentry>
    <term><userinput>a</userinput></term>
    <listitem>
      <para>Identifiant. Ici nous attribuons une valeur à la variable de nom <varname>a</varname>.</para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><userinput>*a</userinput></term>
    <listitem>
      <para>Déréférence un identifiant. Cela attribue une valeur à ce que vers quoi la variable <varname>a</varname> pointe.</para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term><userinput>a@(&lt;région&gt;)</userinput></term>
    <listitem>
      <para>Une région d'une matrice. Ici la région est indiquée normalement comme avec l'opérateur habituel @() et peut être une entrée unique ou une région entière de la matrice.</para>
    </listitem>
  </varlistentry>
</variablelist></para>
      <para>
Examples:
<programlisting>a:=4
*tmp := 89
a@(1,1) := 5
a@(4:8,3) := [1,2,3,4,5]'
</programlisting>
Note that both <literal>:=</literal> and <literal>=</literal> can be used
interchangeably.  Except if the assignment appears in a condition.
It is thus always safer to just use
<literal>:=</literal> when you mean assignment, and <literal>==</literal>
when you mean comparison.
      </para>
    </sect1>

  </chapter>

  <chapter id="genius-gel-programming-advanced">
    <title>Programmation avancée avec GEL</title>

    <sect1 id="genius-gel-error-handling">
      <title>Gestion des erreurs</title>
      <para>Si vous détectez une erreur dans votre fonction, vous pouvez la quitter rapidement (« to bail out of »). Pour les erreurs normales, telles que les mauvais types d'arguments, vous pouvez éviter de calculer la fonction en ajoutant l'instruction <literal>bailout</literal>. Si quelque chose se passe vraiment mal et que vous voulez interrompre complètement le calcul actuel, vous pouvez utiliser l'instruction <literal>exception</literal>.</para>
      <para>Par exemple, si vous voulez vérifier les arguments de votre fonction. Vous pouvez utiliser le code suivant. <programlisting>function f(M) = (
  if not IsMatrix (M) then (
    error ("M n'est pas une matrice !");
    bailout
  );
  ...
)
</programlisting></para>
    </sect1>

    <sect1 id="genius-gel-toplevel-syntax">
      <title>Syntaxe de haut-niveau</title>
      <para>
	The syntax is slightly different if you enter statements on
	the top level versus when they are inside parentheses or
	inside functions.  On the top level, enter acts the same as if
	you press return on the command line.  Therefore think of programs
	as just sequence of lines as if were entered on the command line.
	In particular, you do not need to enter the separator at the end of the
	line (unless it is of course part of several statements inside
	parentheses).
      </para>
      <para>Le code suivant provoque une erreur lorsqu'il est saisi au niveau supérieur d'un programme alors qu'il fonctionne très bien dans une fonction. <programlisting>if QuelqueChose() then
  FaireQuelqueChose()
else
  FaireAutreChose()
</programlisting></para>
      <para>Le problème est que lorsque l'<application>Outil de maths Genius</application> rencontre la fin de la ligne après la seconde ligne, il décide que l'instruction est complète et il l'exécute. Après l'exécution l'<application>Outil de maths Genius</application> se rend à la ligne suivante, voit l'instruction <literal>else</literal> et affiche une erreur de syntaxe. Pour régler ce problème, utilisez des parenthèses. L'<application>Outil de maths Genius</application> ne sera pas satisfait tant qu'il n'aura pas trouvé que toutes les parenthèses sont fermées. <programlisting>if QuelqueChose() then(
  FaireQuelqueChose()
) else (
  FaireAutreChose()
)
</programlisting></para>
    </sect1>

     <sect1 id="genius-gel-returning-functions">
       <title>Renvoi de fonction</title>
	<para>Il est possible de renvoyer des fonctions en tant que donnée. De cette manière, vous pouvez écrire une fonction qui construit des fonctions dans un but précis en fonction de certains paramètres. Le point délicat est de savoir quelles variables sont visibles par la fonction construite. La façon dont cela fonctionne dans GEL est que, lorsqu'une fonction renvoie une autre fonction, tous les identifiants qui étaient référencés dans le corps de la fonction mère, et qui deviendraient hors de portée, sont en fait ajoutés dans un dictionnaire privé de la fonction renvoyée. Ainsi la fonction voit toutes les variables qui étaient à sa portée au moment où elle a été définie. Par exemple, nous pouvons définir ainsi une fonction qui renvoie une fonction qui ajoute 5 à son argument : <programlisting>function f() = (
  k = 5;
  `(x) = (x+k)
)
</programlisting> Notez que la fonction ajoute <varname>k</varname> à <varname>x</varname>. Vous pouvez l'utiliser ainsi. <programlisting>g = f();
g(5)
</programlisting> et <userinput>g(5)</userinput> doit renvoyer 10.</para>
	<para>Une chose à noter est que la valeur de <varname>k</varname> utilisée est celle qui est en cours lorsque la fonction <function>f</function> a terminé son exécution. Par exemple : <programlisting>function f() = (
  k := 5;
  function r(x) = (x+k);
  k := 10;
  r
)
</programlisting> renvoie une fonction qui ajoute 10 à son argument plutôt que 5. La raison est que le dictionnaire supplémentaire est créé uniquement lorsque le contexte dans lequel la fonction a été définie, se termine, c'est-à-dire lorsque la fonction <function>f</function> renvoie. C'est cohérent avec la manière dont on s'attend à ce que la fonction <function>r</function> fonctionne à l'intérieur de la fonction <function>f</function> d'après les règles sur la portée des variables dans GEL. Les seules variables ajoutées au dictionnaire supplémentaire sont celles qui sont présentes dans le contexte qui se termine et n'existe plus. Les variables utilisées dans la fonction, qui sont toujours dans des contextes valides, fonctionnent comme d'habitude, en utilisant la valeur actuelle de la variable. La seule différence, c'est pour les variables et les fonctions globales. Tous les identifiants qui référencent des variables globales au moment de la définition de la fonction ne sont pas ajoutés au dictionnaire privé. C'est pour éviter beaucoup de travail non nécessaire lors du renvoi de fonctions et cela ne pose que rarement problème. Par exemple, supposons que vous supprimiez le « k= 5 » de la fonction <function>f</function> et qu'au niveau supérieur vous définissiez <varname>k</varname> à 5 par exemple. Alors lorsque vous exécutez <function>f</function>, la fonction <function>r</function> ne met pas <varname>k</varname> dans le dictionnaire privé parce qu'il était global (au niveau supérieur) au moment de la définition de <function>r</function>.</para>
	<para>Parfois il est préférable d'avoir un meilleur contrôle sur la façon dont les variables sont copiées dans le dictionnaire privé. Depuis la version 1.0.7, vous pouvez spécifier quelles variables sont copiées dans le dictionnaire privée en mettant des crochets carrés supplémentaires après les arguments contenant la liste des variables qui seront copiées, séparées par des virgules. Si vous faites cela alors les variables sont copiées dans le dictionnaire privé au moment de la définition de la fonction et le dictionnaire privé n'est pas modifié ensuite. Par exemple, <programlisting>function f() = (
  k := 5;
  function r(x) [k] = (x+k);
  k := 10;
  r
)
</programlisting> renvoie une fonction qui, lorsqu'elle est appelée, ajoute 5 à ses arguments. La copie locale de <varname>k</varname> a été créée lorsque la fonction a été définie.</para>
	<para>
	  When you want the function to not have any private dictionary
	  then put empty square brackets after the argument list.  Then
	  no private dictionary will be created at all.  Doing this is
	  good to increase efficiency when a private dictionary is not
	  needed or when you want the function to lookup all variables
	  as it sees them when called.  For example suppose you want
	  the function returned from <function>f</function> to see
	  the value of <varname>k</varname> from the toplevel despite
	  there being a local variable of the same name during definition.
	  So the code
<programlisting>function f() = (
  k := 5;
  function r(x) [] = (x+k);
  r
);
k := 10;
g = f();
g(10)
</programlisting>
	  will return 20 and not 15, which would happen if
	  <varname>k</varname> with a value of 5 was added to the private
	  dictionary.
	</para>
    </sect1>

    <sect1 id="genius-gel-true-local-variables">
      <title>Variables locales vraies</title>
      <para>Lors de la transmission de fonctions dans d'autres fonctions, la portée normale des variables peut être indésirable. Par exemple : <programlisting>k := 10;
function r(x) = (x+k);
function f(g,x) = (
  k := 5;
  g(x)
);
f(r,1)
</programlisting> vous souhaitez probablement que la fonction <function>r</function> lorsqu'elle est transmise à <function>g</function> dans <function>f</function>, puisse voir <varname>k</varname> comme 10 plutôt que 5 afin que le code renvoie 11 et pas 6. Cependant, tel que c'est écrit, la fonction lorsqu'elle est exécutée voit la variable <varname>k</varname> qui est égale à 5. Il y a deux façons de résoudre cela. L'une est que la fonction <function>r</function> obtienne <varname>k</varname> dans un dictionnaire privé en utilisant la notation crochet carré de la section <link linkend="genius-gel-returning-functions">Renvoi de fonctions</link>.</para>
      <para>
	But there is another solution.  Since version 1.0.7 there are
	true local variables.  These are variables that are visible only
	from the current context and not from any called functions.
	We could define <varname>k</varname> as a local variable in the
	function <function>f</function>.  To do this add a
	<command>local</command> statement as the first statement in the
	function (it must always be the first statement in the function).
	You can also make any arguments be local variables as well.
	That is,
<programlisting>function f(g,x) = (
  local g,x,k;
  k := 5;
  g(x)
);
</programlisting>
	Then the code will work as expected and prints out 11.
	Note that the <command>local</command> statement initializes
	all the referenced variables (except for function arguments) to
	a <constant>null</constant>.
      </para>
      <para>
	If all variables are to be created as locals you can just pass an
	asterisk instead of a list of variables.  In this case the variables
	will not be initialized until they are actually set of course.
	So the following definition of <function>f</function>
	will also work:
<programlisting>function f(g,x) = (
  local *;
  k := 5;
  g(x)
);
</programlisting>
      </para>
      <para>C'est une bonne pratique que toutes les fonctions qui prennent d'autres fonctions comme argument, utilisent des variables locales. De cette manière, la fonction transmise ne voit pas les détails de l'implémentation et n'est pas perturbée.</para>
    </sect1>

    <sect1 id="genius-gel-startup-procedure">
      <title>Procédure de démarrage de GEL</title>
      <para>Dans un premier temps, le programme recherche dans le répertoire d'installation les fichiers de la bibliothèque installés (la version compilée <filename>lib.cgel</filename>), puis il recherche dans le répertoire actuel, puis il essaye de charger un fichier non compilé appelé <filename>~/.geniusinit</filename>.</para>
      <para>
If you ever change the library in its installed place, you’ll have to
first compile it with <command>genius --compile loader.gel &gt; lib.cgel</command>
      </para>
    </sect1>

    <sect1 id="genius-gel-loading-programs">
      <title>Chargement de programmes</title>
      <para>
Sometimes you have a larger program you wrote into a file and want to read that file into <application>Genius Mathematics Tool</application>. In these situations, you have two options. You can keep the functions you use most inside the <filename>~/.geniusinit</filename> file. Or if you want to load up a file in a middle of a session (or from within another file), you can type <command>load &lt;list of filenames&gt;</command> at the prompt. This has to be done on the top level and not inside any function or whatnot, and it cannot be part of any expression. It also has a slightly different syntax than the rest of genius, more similar to a shell. You can enter the file in quotes. If you use the '' quotes, you will get exactly the string that you typed, if you use the "" quotes, special characters will be unescaped as they are for strings. Example:
<programlisting>load programme1.gel programme2.gel
load "Etrange nom de fichier avec des ESPACES.gel"
</programlisting>
There are also <command>cd</command>, <command>pwd</command> and <command>ls</command> commands built in. <command>cd</command> will take one argument, <command>ls</command> will take an argument that is like the glob in the UNIX shell (i.e., you can use wildcards). <command>pwd</command> takes no arguments. For example:
<programlisting>cd repertoire_contenant_des_programmes_gel
ls *.gel
</programlisting>
      </para>
    </sect1>

  </chapter>

  <!-- ============= Matrices ================================= -->
  <chapter id="genius-gel-matrices">
    <title>Matrices en GEL</title>

    <para>
      Genius has support for vectors and matrices and possesses a sizable library of
      matrix manipulation and linear algebra functions.
    </para>

    <sect1 id="genius-gel-matrix-support">
      <title>Saisie de matrices</title>
      <para>
To enter matrices, you can use one of the following two syntaxes. You can either enter
the matrix on one line, separating values by commas and rows by semicolons.  Or you
can enter each row on one line, separating
values by commas.
You can also just combine the two methods.
So to enter a 3x3 matrix
of numbers 1-9 you could do
<programlisting>[1,2,3;4,5,6;7,8,9]
</programlisting>
or
<programlisting>[1, 2, 3
 4, 5, 6
 7, 8, 9]
</programlisting>
Do not use both ';' and return at once on the same line though.
      </para>

      <para>
You can also use the matrix expansion functionality to enter matrices.
For example you can do:
<programlisting>a = [ 1, 2, 3
      4, 5, 6
      7, 8, 9]
b = [ a,  10
      11, 12]
</programlisting>
and you should get
<programlisting>[1,   2,  3, 10
 4,   5,  6, 10
 7,   8,  9, 10
 11, 11, 11, 12]
</programlisting>
similarly you can build matrices out of vectors and other stuff like that.
      </para>

      <para>Notez que les éléments non spécifiés sont initialisés à 0, donc <programlisting>[1, 2, 3
 4, 5
 6]
</programlisting> donne au final <programlisting>
[1, 2, 3
 4, 5, 0
 6, 0, 0]
</programlisting></para>

      <para>
	When matrices are evaluated, they are evaluated and traversed row-wise.  This is just
	like the <literal>M@(j)</literal> operator, which traverses the matrix row-wise.
      </para>

      <note>
        <para>Faites attention lorsque vous utilisez des retours à la ligne à l'intérieur des crochets <literal>[ ]</literal> car ils ont une signification légèrement différente dans ce cas. Vous commencez une nouvelle ligne.</para>
      </note>

    </sect1>

    <sect1 id="genius-gel-matrix-transpose">
      <title>Opérateur de transposition conjuguée et de transposition</title>
      <para>Vous pouvez obtenir la matrice transposée conjuguée grâce à l'opérateur <literal>'</literal>. Cela signifie que la valeur dans la <varname>i</varname>ième colonne et la <varname>j</varname>ième ligne est le complexe conjugué de la valeur dans la <varname>j</varname>ième colonne et la <varname>i</varname>ième ligne de la matrice d'origine. Dans l'exemple : <programlisting>[1,2,3]*[4,5,6]'
</programlisting> il faut transposer la deuxième matrice pour permettre la multiplication des matrices. Si vous voulez juste transposer une matrice sans la conjuguer, vous devez utiliser l'opérateur <literal>.'</literal>. Par exemple : <programlisting>[1,2,3]*[4,5,6i].'
</programlisting></para>
	<para>Remarquez que la transposée normale, c'est-à-dire l'opérateur <literal>.'</literal>, est beaucoup plus rapide et ne crée pas une nouvelle copie de la matrice en mémoire. La transposition conjuguée crée hélas une nouvelle copie. Il est recommandé de toujours utiliser l'opérateur <literal>.'</literal> lorsque vous travaillez avec des matrices et des vecteurs non complexes.</para>
    </sect1>

    <sect1 id="genius-gel-matrix-linalg">
      <title>Algèbre linéaire</title>
      <para>Genius implémente beaucoup de routines utiles d'algèbre linéraire et de manipulation de matrice. Consultez les sections <link linkend="genius-gel-function-list-linear-algebra">Algèbre linéaire</link> et <link linkend="genius-gel-function-list-matrix">Manipulation de matrice</link> dans la liste des fonctions GEL.</para>
      <para>Les routines d'algèbre linéaire implémentées en GEL ne proviennent pas actuellement d'un paquet numérique bien testé et ne doivent donc pas être utilisées pour des calculs numériques critiques. D'un autre côté, Genius implémente très bien les nombreuses opérations d'algèbre linéaire avec des coefficients rationnels et entiers. Elles sont par nature exactes et en fait vous donnent de bien meilleurs résultats que les routines en double précision usuelles pour l'algèbre linéaire.</para>
      <para>Par exemple, il est vain de calculer le rang et le noyau d'une matrice réelle puisque dans tous les cas pratiques, il faut considérer que la matrice contienne de légères erreurs. Il est possible que vous obteniez un résultat différent de ce que vous attendiez. Le problème est qu'en faisant une légère perturbation toute matrice est de rang complet et inversible. Cependant si la matrice est composée de nombres rationnels alors le rang et le noyau sont toujours exactes.</para>
      <para>
	In general when Genius computes the basis of a certain vectorspace
	(for example with the <link linkend="gel-function-NullSpace"><function>NullSpace</function></link>) it will give the basis as
a matrix, in which the columns are the vectors of the basis.  That is, when
Genius talks of a linear subspace it means a matrix whose column space is
the given linear subspace.
      </para>
      <para>
	It should be noted that Genius can remember certain properties of a
matrix.  For example, it will remember that a matrix is in row reduced form.
If many calls are made to functions that internally use row reduced form of
the matrix, we can just row reduce the matrix beforehand once.  Successive
calls to <link linkend="gel-function-rref"><function>rref</function></link> will be very fast.
      </para>
    </sect1>

  </chapter>

  <!-- ============= Polynomials ============================== -->
  <chapter id="genius-gel-polynomials">
    <title>Polynômes en GEL</title>

    <para>Actuellement Genius peut prendre en charge des polynômes à une variable écrits sous la forme de vecteurs et réaliser des opérations élémentaires avec eux. Il est prévu d'étendre cette prise en charge.</para>

    <sect1 id="genius-gel-polynomials-using">
      <title>Utilisation des polynômes</title>
      <para>Actuellement les polynômes à une variable sont juste des vecteurs lignes dont les valeurs sont les coefficients. La puissance du terme est la position dans le vecteur, la première étant 0. Ainsi, <programlisting>[1,2,3]
</programlisting> représente le polynôme <programlisting>1 + 2*x + 3*x^2
</programlisting></para>
      <para>Vous pouvez ajouter, soustraire et multiplier des polynômes en utilisant respectivement les fonctions <link linkend="gel-function-AddPoly"><function>AddPoly</function></link>, <link linkend="gel-function-SubtractPoly"><function>SubtractPoly</function></link> et <link linkend="gel-function-MultiplyPoly"><function>MultiplyPoly</function></link>. Vous pouvez afficher un polynôme en utilisant la fonction <link linkend="gel-function-PolyToString"><function>PolyToString</function></link>. Par exemple, <programlisting>PolyToString([1,2,3],"y")
</programlisting> donne <programlisting>3*y^2 + 2*y + 1
</programlisting> Vous pouvez également obtenir une représentation fonctionnelle du polynôme afin de pouvoir l'évaluer. Pour cela, utilisez <link linkend="gel-function-PolyToFunction"><function>PolyToFunction</function></link> qui renvoie une fonction anonyme. <programlisting>f = PolyToFunction([0,1,1])
f(2)
</programlisting></para>
      <para>Il est aussi possible de trouver les racines des polynômes de degré 1 à 4 en utilisant la fonction <link linkend="gel-function-PolynomialRoots"><function>PolynomialRoots</function></link> qui appelle la formule appropriée. Les polynômes de degré supérieur doit être convertis en fonctions et résolus numériquement en utilisant une fonction telle que <link linkend="gel-function-FindRootBisection"><function>FindRootBisection</function></link>, <link linkend="gel-function-FindRootFalsePosition"><function>FindRootFalsePosition</function></link>, <link linkend="gel-function-FindRootMullersMethod"><function>FindRootMullersMethod</function></link> ou <link linkend="gel-function-FindRootSecant"><function>FindRootSecant</function></link>.</para>
      <para>Consultez <xref linkend="genius-gel-function-list-polynomials"/> dans la liste des fonctions pour le reste des fonctions agissant sur les polynômes.</para>
    </sect1>

  </chapter>

  <!-- ============= Set Theory ============================== -->
  <chapter id="genius-gel-settheory">
    <title>Théorie des ensembles en GEL</title>

    <para>Genius possède des fonctionnalités intégrées basiques concernant la théorie des ensembles. Actuellement un ensemble est juste un vecteur (ou une matrice). Chaque objet distinct est traité comme un élément différent.</para>

    <sect1 id="genius-gel-sets-using">
      <title>Utilisation des ensembles</title>
      <para>Tout comme les vecteurs, les objets dans les ensembles peuvent comprendre des nombres, des chaînes de caractères, <constant>null</constant>, des matrices et des vecteurs. Il est prévu dans le futur d'avoir un type dédié pour les ensembles plutôt que d'utiliser des vecteurs. Notez que les nombres flottants sont différents des entiers, même s'ils semblent être les mêmes. Cela signifie que Genius traite <constant>0</constant> et <constant>0.0</constant> comme deux éléments différents. La constante <constant>null</constant> est traitée comme un ensemble vide.</para>
      <para>Pour construire un ensemble à partir d'un vecteur, utilisez la fonction <link linkend="gel-function-MakeSet"><function>MakeSet</function></link>. Actuellement, cela renvoie juste un nouveau vecteur où chaque élément est unique. <screen><prompt>genius&gt; </prompt><userinput>MakeSet([1,2,2,3])</userinput>
= [1, 2, 3]
</screen></para>

	<para>De manière similaire, il existe des fonctions <link linkend="gel-function-Union"><function>Union</function></link>, <link linkend="gel-function-Intersection"><function>Intersection</function></link>, <link linkend="gel-function-SetMinus"><function>SetMinus</function></link> dont le but est assez intuitif. Par exemple : <screen><prompt>genius&gt; </prompt><userinput>Union([1,2,3], [1,2,4])</userinput>
= [1, 2, 4, 3]
</screen> Notez qu'aucun ordre n'est garanti pour les valeurs renvoyées. Si vous souhaitez trier le vecteur, vous devez utiliser la fonction <link linkend="gel-function-SortVector"><function>SortVector</function></link>.</para>

	<para>Pour tester l'appartenance, il existe les fonctions <link linkend="gel-function-IsIn"><function>IsIn</function></link> et <link linkend="gel-function-IsSubset"><function>IsSubset</function></link> qui renvoient une valeur booléenne. Par exemple, <screen><prompt>genius&gt; </prompt><userinput>IsIn (1, [0,1,2])</userinput>
= true
</screen> La syntaxe <userinput>IsIn(x,X)</userinput> est bien sûr équivalente à <userinput>IsSubset([x],X)</userinput>. Notez que puisque l'ensemble vide est un sous-ensemble de tous les ensembles, <userinput>IsSubset(null,X)</userinput> est toujours vrai.</para>

    </sect1>

  </chapter>

  <!-- ============= GEL function list ======================== -->
  <chapter id="genius-gel-function-list">
    <title>Liste des fonctions GEL</title>

    <!--&gel-function-list;-->

    <para>Pour obtenir de l'aide sur une fonction spécifique à partir de la console, saisissez : <programlisting>help NomDeLaFonction
</programlisting></para>

    <sect1 id="genius-gel-function-list-commands">
      <title>Commandes</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-command-help"/>help</term>
         <listitem>
          <synopsis>help</synopsis>
          <synopsis>help NomDeLaFonction</synopsis>
          <para>Affiche l'aide (ou l'aide d'une fonction/commande).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-command-load"/>load</term>
         <listitem>
          <synopsis>load "fichier.gel"</synopsis>
          <para>Load a file into the interpreter.  The file will execute
as if it were typed onto the command line.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-command-cd"/>cd</term>
         <listitem>
          <synopsis>cd /nom/de/repertoire</synopsis>
          <para>Change le répertoire de travail en <filename>/nom/de/repertoire</filename>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-command-pwd"/>pwd</term>
         <listitem>
          <synopsis>pwd</synopsis>
          <para>Affiche le répertoire de travail.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-command-ls"/>ls</term>
         <listitem>
          <synopsis>ls</synopsis>
          <para>Affiche les fichiers dans le répertoire.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-command-plugin"/>plugin</term>
         <listitem>
          <synopsis>plugin nom_du_greffon</synopsis>
          <para>Charge un greffon. Le greffon portant ce nom doit être installé sur votre système dans le répertoire correct.</para>
         </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-basic">
      <title>Basique</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-AskButtons"/>AskButtons</term>
         <listitem>
          <synopsis>AskButtons (requête)</synopsis>
          <synopsis>AskButtons (requête, bouton1, ...)</synopsis>
	  <para>Pose une question et présente une liste de boutons à l'utilisateur (ou un menu d'options en mode texte). Renvoie l'indice du bouton enfoncé, commençant à 1, c'est-à-dire renvoie 1 si le premier bouton est enfoncé, 2 si le second bouton est enfoncé, etc. Si l'utilisateur ferme la fenêtre (ou appui sur Entrée en mode texte) alors <constant>null</constant> est renvoyé. L'exécution du programme est bloqué jusqu'à ce que l'utilisateur réponde.</para>
	  <para>Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-AskString"/>AskString</term>
         <listitem>
          <synopsis>AskString (requête)</synopsis>
          <synopsis>AskString (requête, défaut)</synopsis>
          <para>Asks a question and lets the user enter a string, which
it then returns.  If the user cancels or closes the window, then
<constant>null</constant> is returned.  The execution of the program
is blocked until the user responds.  If <varname>default</varname> is given, then it is pre-typed in for the user to just press enter on (version 1.0.6 onwards).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Compose"/>Compose</term>
         <listitem>
          <synopsis>Compose (f,g)</synopsis>
          <para>Compose deux fonctions et renvoie une fonction qui est la composition de <function>f</function> par <function>g</function>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ComposePower"/>ComposePower</term>
         <listitem>
          <synopsis>ComposePower (f,n,x)</synopsis>
          <para>Compose et exécute une fonction avec elle-même <varname>n</varname> fois en transmettant l'argument <varname>x</varname>. Cela renvoie <varname>x</varname> si <varname>n</varname> vaut 0. Exemple : <screen><prompt>genius&gt;</prompt> <userinput>function f(x) = x^2 ;</userinput>
<prompt>genius&gt;</prompt> <userinput>ComposePower (f,3,7)</userinput>
= 5764801
<prompt>genius&gt;</prompt> <userinput>f(f(f(7)))</userinput>
= 5764801
</screen></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Evaluate"/>Evaluate</term>
         <listitem>
          <synopsis>Evaluate (chaîne)</synopsis>
          <para>Analyse et évalue une chaîne.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><anchor id="gel-function-GetCurrentModulo"/>GetCurrentModulo</term>
         <listitem>
          <synopsis>GetCurrentModulo</synopsis>
          <para>Obtient le modulo actuel à partir du contexte extérieur à la fonction. C'est-à-dire, si l'extérieur de la fonction a été exécuté en mode modulo (en utilisant <literal>mod</literal>) alors cela renvoie cette valeur de modulo. Normalement le corps d'une fonction appelée n'est pas exécutée en arithmétique modulaire et cette fonction intégrée donne la possibilité aux fonctions GEL de prendre connaissance de l'arithmétique modulaire en cours.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Identity"/>Identity</term>
         <listitem>
          <synopsis>Identity (x)</synopsis>
	  <para>Identity function, returns its argument.  It is equivalent to <userinput>function Identity(x)=x</userinput>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IntegerFromBoolean"/>IntegerFromBoolean</term>
         <listitem>
          <synopsis>IntegerFromBoolean (val_bool)</synopsis>
	  <para>Crée un entier (0 pour <constant>false</constant> ou 1 pour <constant>true</constant>) à partir d'une valeur booléenne. <varname>val_bool</varname> peut également être un nombre et dans ce cas une valeur non nulle est interprétée comme <constant>true</constant> et zéro est interprété comme <constant>false</constant>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsBoolean"/>IsBoolean</term>
         <listitem>
          <synopsis>IsBoolean (param)</synopsis>
          <para>Vérifie que l'argument est un booléen (et pas un nombre).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsDefined"/>IsDefined</term>
         <listitem>
          <synopsis>IsDefined (id)</synopsis>
          <para>Vérifie qu'un identifiant est défini. Vous devez transmettre une chaîne de caractères ou un identifiant. Si vous transmettez une matrice, chaque entrée est évaluée séparément et la matrice doit contenir des chaînes ou des identifiants.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsFunction"/>IsFunction</term>
         <listitem>
          <synopsis>IsFunction (param)</synopsis>
          <para>Vérifie que l'argument est une fonction.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsFunctionOrIdentifier"/>IsFunctionOrIdentifier</term>
         <listitem>
          <synopsis>IsFunctionOrIdentifier (param)</synopsis>
          <para>Vérifie que l'argument est une fonction ou un identificateur.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsFunctionRef"/>IsFunctionRef</term>
         <listitem>
          <synopsis>IsFunctionRef (param)</synopsis>
          <para>Vérifie que l'argument est une référence de fonction. Cela inclut les références de variable.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsMatrix"/>IsMatrix</term>
         <listitem>
          <synopsis>IsMatrix (param)</synopsis>
          <para>Vérifie que l'argument est une matrice. Même si <constant>null</constant> est parfois considéré comme une matrice vide, la fonction <function>IsMatrix</function> ne considère pas <constant>null</constant> comme une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsNull"/>IsNull</term>
         <listitem>
          <synopsis>IsNull (param)</synopsis>
	  <para>Vérifie que l'argument est <constant>null</constant>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsString"/>IsString</term>
         <listitem>
          <synopsis>IsString (param)</synopsis>
          <para>Vérifie que l'argument est une chaîne de caractères.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsValue"/>IsValue</term>
         <listitem>
          <synopsis>IsValue (param)</synopsis>
          <para>Vérifie que l'argument est un nombre.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Parse"/>Parse</term>
         <listitem>
          <synopsis>Parse (chaîne)</synopsis>
          <para>Analyse mais n'évalue pas une chaîne de caractères. Notez que certains pré-calculs sont effectués pendant l'étape d'évaluation.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SetFunctionFlags"/>SetFunctionFlags</term>
         <listitem>
          <synopsis>SetFunctionFlags (id,drapeau...)</synopsis>
          <para>Définit des drapeaux pour une fonction, actuellement <literal>« PropagateMod »</literal> et <literal>« NoModuloArguments »</literal>. Si <literal>« PropagateMod »</literal> est défini alors le corps de la fonction est évalué en arithmétique modulaire lorsque la fonction est appelée à l'intérieur d'un bloc qui est évalué en utilisant l'arithmétique modulaire (en utilisant <literal>mod</literal>). Si <literal>« NoModuloArguments »</literal> est défini alors les arguments de la fonction ne sont jamais évalués en arithmétique modulaire.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SetHelp"/>SetHelp</term>
         <listitem>
          <synopsis>SetHelp (id,categorie,desc)</synopsis>
          <para>Définit une catégorie et une ligne de description d'aide pour une fonction.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SetHelpAlias"/>SetHelpAlias</term>
         <listitem>
          <synopsis>SetHelpAlias (id,alias)</synopsis>
          <para>Met en place un pseudonyme pour l'aide.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-chdir"/>chdir</term>
         <listitem>
          <synopsis>chdir (rep)</synopsis>
          <para>Change le répertoire actuel, tout comme la commande <command>cd</command>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CurrentTime"/>CurrentTime</term>
         <listitem>
          <synopsis>CurrentTime</synopsis>
          <para>Renvoie l'heure UNIX courante avec une précision de l'ordre de la microseconde sous forme d'un nombre à virgule flottante, c'est-à-dire le nombre de secondes écoulées depuis le 1er janvier 1970.</para>
	  <para>Version 1.0.15 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-display"/>display</term>
         <listitem>
          <synopsis>display (chaîne,expr)</synopsis>
          <para>Affiche une chaîne de caractères et une expression séparées par deux points.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DisplayVariables"/>DisplayVariables</term>
         <listitem>
          <synopsis>DisplayVariables (var1,var2,...)</synopsis>
	  <para>Display set of variables.  The variables can be given as
		  strings or identifiers.  For example:
	    <programlisting>DisplayVariables(`x,`y,`z)
	    </programlisting>
	  </para>
	  <para>
		  If called without arguments (must supply empty argument list) as
	    <programlisting>DisplayVariables()
	    </programlisting>
	    then all variables are printed including a stacktrace similar to
	    <guilabel>Show user variables</guilabel> in the graphical version.
	  </para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-error"/>error</term>
         <listitem>
          <synopsis>error (chaîne)</synopsis>
          <para>Affiche une chaîne vers la sortie erreur (dans la console).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-exit"/>exit</term>
         <listitem>
          <synopsis>exit</synopsis>
          <para>Alias : <function>quit</function></para>
          <para>Quitte le programme.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-false"/>false</term>
         <listitem>
          <synopsis>false</synopsis>
          <para>Alias : <function>False</function>, <function>FALSE</function></para>
	  <para>La valeur booléenne <constant>false</constant> (faux).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-manual"/>manual</term>
         <listitem>
          <synopsis>manual</synopsis>
          <para>Affiche le manuel utilisateur.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-print"/>print</term>
         <listitem>
          <synopsis>print (chaîne)</synopsis>
          <para>Affiche une expression suivie d'un retour à la ligne. L'argument <varname>chaine</varname> peut être n'importe quelle expression. Elle est transformée en chaîne avant d'être affichée.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-printn"/>printn</term>
         <listitem>
          <synopsis>printn (chaîne)</synopsis>
          <para>Affiche une expression non suivie d'un retour à la ligne. L'argument <varname>chaine</varname> peut être n'importe quelle expression. Elle est transformée en chaîne avant d'être affichée.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PrintTable"/>PrintTable</term>
         <listitem>
          <synopsis>PrintTable (f,v)</synopsis>
	  <para>Print a table of values for a function.  The values are in the 
		  vector <varname>v</varname>.  You can use the vector
		  building notation as follows:
      		  <programlisting>PrintTable (f,[0:10])
	    </programlisting>
	    If <varname>v</varname> is a positive integer, then the table of
	    integers from 1 up to and including v will be used.
	  </para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-protect"/>protect</term>
         <listitem>
          <synopsis>protect (id)</synopsis>
          <para>Protège une variable de la modification. C'est utilisé dans les fonctions internes de GEL pour leur éviter d'être accidentellement écrasées.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ProtectAll"/>ProtectAll</term>
         <listitem>
          <synopsis>ProtectAll ()</synopsis>
          <para>Protège toutes les variables, paramètres et fonctions actuellement définis de la modification. C'est utilisé dans les fonctions internes de GEL pour leur éviter d'être accidentellement écrasées. Normalement l'<application>Outil de maths Genius</application> considère que les variables non protégées sont définies par l'utilisateur.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-set"/>set</term>
         <listitem>
          <synopsis>set (id,val)</synopsis>
          <para>Set a global variable.  The <varname>id</varname>
            can be either a string or a quoted identifier.
	    For example:
	    <programlisting>set(`x,1)
	    </programlisting>
	    will set the global variable <varname>x</varname> to the value 1.
	  </para>
	  <para>The function returns the <varname>val</varname>, to be
	  usable in chaining.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SetElement"/>SetElement</term>
         <listitem>
          <synopsis>SetElement (id,row,col,val)</synopsis>
	  <para>Set an element of a global variable which is a matrix.
		  The <varname>id</varname>
            can be either a string or a quoted identifier.
	    For example:
	    <programlisting>SetElement(`x,2,3,1)
	    </programlisting>
	    will set the second row third column element of the global variable <varname>x</varname> to the value 1.  If no global variable of the name exists, or if it is set to something that's not a matrix, a new zero matrix of appropriate size will be created.
	  </para>
	  <para>The <varname>row</varname> and <varname>col</varname> can also be ranges, and the semantics are the same as for regular setting of the elements with an equals sign.
	  </para>
	  <para>The function returns the <varname>val</varname>, to be
	  usable in chaining.</para>
	  <para>Available from 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SetVElement"/>SetVElement</term>
         <listitem>
          <synopsis>SetElement (id,elt,val)</synopsis>
	  <para>Set an element of a global variable which is a vector.
		  The <varname>id</varname>
            can be either a string or a quoted identifier.
	    For example:
	    <programlisting>SetElement(`x,2,1)
	    </programlisting>
	    will set the second element of the global vector variable <varname>x</varname> to the value 1.  If no global variable of the name exists, or if it is set to something that's not a vector (matrix), a new zero row vector of appropriate size will be created.
	  </para>
	  <para>The <varname>elt</varname> can also be a range, and the semantics are the same as for regular setting of the elements with an equals sign.
	  </para>
	  <para>The function returns the <varname>val</varname>, to be
	  usable in chaining.</para>
	  <para>Available from 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-string"/>string</term>
         <listitem>
          <synopsis>string (s)</synopsis>
          <para>Crée une chaîne de caractères à partir de n'importe quel argument.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-true"/>true</term>
         <listitem>
          <synopsis>true</synopsis>
          <para>Alias : <function>True</function>, <function>TRUE</function></para>
	  <para>La valeur booléenne <constant>true</constant> (vrai).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-undefine"/>undefine</term>
         <listitem>
          <synopsis>undefine (id)</synopsis>
          <para>Alias : <function>Undefine</function></para>
          <para>Annule la définition d'une variable, y compris les variables locales et globales, toutes les valeurs dans tous les contextes sont effacées. Vous ne devriez vraiment pas utiliser cette fonction pour des variables locales. Un vecteur d'identifiants peut également être transmis pour annuler la définition de plusieurs variables.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-UndefineAll"/>UndefineAll</term>
         <listitem>
          <synopsis>UndefineAll ()</synopsis>
	  <para>Annule la définition de toutes les variables globales non protégées (y compris les fonctions et les paramètres). Normalement l'<application>Outil de maths Genius</application> considère que les variables protégées sont des variables et des fonctions définies par le système. Notez que <function>UndefineAll</function> efface seulement la définition globale des symboles et pas les définitions locales donc cela peut être utilisé à l'intérieur d'autres fonctions sans danger.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-unprotect"/>unprotect</term>
         <listitem>
          <synopsis>unprotect (id)</synopsis>
          <para>Annule la protection d'une variable contre sa modification.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-UserVariables"/>UserVariables</term>
         <listitem>
          <synopsis>UserVariables ()</synopsis>
          <para>Renvoie un vecteur d'identifiants des variables globales définies par l'utilisateur (non protégées).</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-wait"/>wait</term>
         <listitem>
          <synopsis>wait (secs)</synopsis>
          <para>Attend un nombre spécifié de secondes. <varname>secs</varname> ne doit pas être négatif. Zéro est accepté et rien ne se passe dans ce cas mis à part, peut-être, le traitement d'évènements de l'interface utilisateur.</para>
	  <para>Since version 1.0.18, <varname>secs</varname> can be a noninteger number, so
		  <userinput>wait(0.1)</userinput> will wait for one tenth of a second.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-version"/>version</term>
         <listitem>
          <synopsis>version</synopsis>
          <para>Renvoie la version de Genius sous la forme d'un vecteur horizontal à 3 valeurs : en premier la version majeure, puis la version mineure et enfin le niveau de correction.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-warranty"/>warranty</term>
         <listitem>
          <synopsis>warranty</synopsis>
          <para>Renvoie les informations sur la garantie.</para>
         </listitem>
        </varlistentry>
      </variablelist>

    </sect1>

    <sect1 id="genius-gel-function-parameters">
      <title>Paramètres</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-ChopTolerance"/>ChopTolerance</term>
         <listitem>
          <synopsis>ChopTolerance = nombre</synopsis>
          <para>Tolérance pour la fonction <function>Chop</function>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ContinuousNumberOfTries"/>ContinuousNumberOfTries</term>
         <listitem>
          <synopsis>ContinuousNumberOfTries = nombre</synopsis>
          <para>Nombre d'itérations à essayer pour rechercher la continuité et les limites d'une fonction.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ContinuousSFS"/>ContinuousSFS</term>
         <listitem>
          <synopsis>ContinuousSFS = nombre</synopsis>
          <para>Nombre d'étapes successives pour atteindre la tolérance pour le calcul de la continuité.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ContinuousTolerance"/>ContinuousTolerance</term>
         <listitem>
          <synopsis>ContinuousTolerance = nombre</synopsis>
          <para>Tolérance pour la continuité d'une fonction et pour le calcul de la limite.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DerivativeNumberOfTries"/>DerivativeNumberOfTries</term>
         <listitem>
          <synopsis>DerivativeNumberOfTries = nombre</synopsis>
          <para>Nombre d'itérations à essayer pour trouver la limite pour la dérivée.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DerivativeSFS"/>DerivativeSFS</term>
         <listitem>
          <synopsis>DerivativeSFS = nombre</synopsis>
          <para>Nombre d'étapes successives pour atteindre la tolérance pour le calcul de la dérivée.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DerivativeTolerance"/>DerivativeTolerance</term>
         <listitem>
          <synopsis>DerivativeTolerance = nombre</synopsis>
          <para>Tolérance pour le calcul de la dérivée des fonctions.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ErrorFunctionTolerance"/>ErrorFunctionTolerance</term>
         <listitem>
          <synopsis>ErrorFunctionTolerance = nombre</synopsis>
	  <para>Tolerance of the <link linkend="gel-function-ErrorFunction"><function>ErrorFunction</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FloatPrecision"/>FloatPrecision</term>
         <listitem>
          <synopsis>FloatPrecision = nombre</synopsis>
          <para>Précision en virgule flottante.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FullExpressions"/>FullExpressions</term>
         <listitem>
          <synopsis>FullExpressions = booléen</synopsis>
          <para>Affiche les expressions complètes, même celles de plus d'une ligne.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-GaussDistributionTolerance"/>GaussDistributionTolerance</term>
         <listitem>
          <synopsis>GaussDistributionTolerance = nombre</synopsis>
	  <para>Tolerance of the <link linkend="gel-function-GaussDistribution"><function>GaussDistribution</function></link> function.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IntegerOutputBase"/>IntegerOutputBase</term>
         <listitem>
          <synopsis>IntegerOutputBase = nombre</synopsis>
          <para>Base de sortie pour les entiers.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPrimeMillerRabinReps"/>IsPrimeMillerRabinReps</term>
         <listitem>
          <synopsis>IsPrimeMillerRabinReps = nombre</synopsis>
	  <para>Number of extra Miller-Rabin tests to run on a number before declaring it a prime in <link linkend="gel-function-IsPrime"><function>IsPrime</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotDrawLegends"/>LinePlotDrawLegends</term>
         <listitem>
          <synopsis>LinePlotDrawLegends = true</synopsis>
          <para>Indique à genius de tracer les légendes pour les <link linkend="genius-gel-function-list-plotting">fonctions de tracé de graphiques</link> telles que <link linkend="gel-function-LinePlot"><function>LinePlot</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotDrawAxisLabels"/>LinePlotDrawAxisLabels</term>
         <listitem>
          <synopsis>LinePlotDrawAxisLabels = true</synopsis>
          <para>Tells genius to draw the axis labels for <link linkend="genius-gel-function-list-plotting">line plotting
	  functions</link> such as <link linkend="gel-function-LinePlot"><function>LinePlot</function></link>.
          </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotVariableNames"/>LinePlotVariableNames</term>
         <listitem>
          <synopsis>LinePlotVariableNames = ["x","y","z","t"]</synopsis>
          <para>Indique à Genius les noms des variables utilisés pour les <link linkend="genius-gel-function-list-plotting">fonctions de tracé de graphiques</link> telles que <link linkend="gel-function-LinePlot"><function>LinePlot</function></link> et autres.</para>
	  <para>Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotWindow"/>LinePlotWindow</term>
         <listitem>
          <synopsis>LinePlotWindow = [x1,x2,y1,y2]</synopsis>
          <para>Définit les limites pour les <link linkend="genius-gel-function-list-plotting">fonctions de tracé de graphiques</link> telles que <link linkend="gel-function-LinePlot"><function>LinePlot</function></link>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><anchor id="gel-function-MaxDigits"/>MaxDigits</term>
         <listitem>
          <synopsis>MaxDigits = nombre</synopsis>
          <para>Nombre maximum de chiffres à afficher.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MaxErrors"/>MaxErrors</term>
         <listitem>
          <synopsis>MaxErrors = nombre</synopsis>
          <para>Nombre maximum d'erreurs à afficher.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MixedFractions"/>MixedFractions</term>
         <listitem>
          <synopsis>MixedFractions = booléen</synopsis>
          <para>Si vrai, les fractions mixtes sont affichées.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalIntegralFunction"/>NumericalIntegralFunction</term>
         <listitem>
          <synopsis>NumericalIntegralFunction = fonction</synopsis>
	  <para>The function used for numerical integration in <link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalIntegralSteps"/>NumericalIntegralSteps</term>
         <listitem>
          <synopsis>NumericalIntegralSteps = nombre</synopsis>
	  <para>Steps to perform in <link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-OutputChopExponent"/>OutputChopExponent</term>
         <listitem>
          <synopsis>OutputChopExponent = nombre</synopsis>
	  <para>Lorsqu'un autre nombre dans l'objet qui est affiché (une matrice ou une valeur) est plus grand que 10<superscript>-OutputChopWhenExponent</superscript> et que le nombre actuellement affiché est inférieur à 10<superscript>-OutputChopExponent</superscript> alors afficher <computeroutput>0.0</computeroutput> au lieu du nombre.</para>
<para>La sortie n'est jamais tronquée si <function>OutputChopExponent</function> vaut zéro. Cela doit être un nombre entier positif.</para>
<para>Si vous voulez toujours que la sortie soit tronquée selon <function>OutputChopExponent</function> alors définissez <function>OutputChopWhenExponent</function> à quelque chose de supérieur ou égal à <function>OutputChopExponent</function>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-OutputChopWhenExponent"/>OutputChopWhenExponent</term>
         <listitem>
          <synopsis>OutputChopWhenExponent = nombre</synopsis>
	  <para>Définit quand la sortie est tronquée. Consultez <link linkend="gel-function-OutputChopExponent"><function>OutputChopExponent</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-OutputStyle"/>OutputStyle</term>
         <listitem>
          <synopsis>OutputStyle = chaîne</synopsis>
          <para>Style des affichages, cela peut être <literal>normal</literal>, <literal>latex</literal>, <literal>mathml</literal> ou <literal>troff</literal>.</para>
	  <para>Cela affecte principalement la façon dont les matrices et les fractions sont affichées et est utile pour le copier/coller vers des documents. Par exemple, vous pouvez définir ce paramètre à « latex » par : <programlisting>OutputStyle = "latex"
</programlisting></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ResultsAsFloats"/>ResultsAsFloats</term>
         <listitem>
          <synopsis>ResultsAsFloats = booléen</synopsis>
          <para>Convertit tous les résultats en nombres flottants avant de les afficher.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ScientificNotation"/>ScientificNotation</term>
         <listitem>
          <synopsis>ScientificNotation = booléen</synopsis>
          <para>Utilise la notation scientifique.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SlopefieldTicks"/>SlopefieldTicks</term>
         <listitem>
          <synopsis>SlopefieldTicks = [verticale,horizontale]</synopsis>
          <para>Définit le nombre de petits traits verticaux et horizontaux dans un graphique de champ de tangente (consultez <link linkend="gel-function-SlopefieldPlot"><function>SlopefieldPlot</function></link>).</para>
	  <para>Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SumProductNumberOfTries"/>SumProductNumberOfTries</term>
         <listitem>
          <synopsis>SumProductNumberOfTries = nombre</synopsis>
	  <para>How many iterations to try for <link linkend="gel-function-InfiniteSum"><function>InfiniteSum</function></link> and <link linkend="gel-function-InfiniteProduct"><function>InfiniteProduct</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SumProductSFS"/>SumProductSFS</term>
         <listitem>
          <synopsis>SumProductSFS = nombre</synopsis>
          <para>How many successive steps to be within tolerance for <link linkend="gel-function-InfiniteSum"><function>InfiniteSum</function></link> and <link linkend="gel-function-InfiniteProduct"><function>InfiniteProduct</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SumProductTolerance"/>SumProductTolerance</term>
         <listitem>
          <synopsis>SumProductTolerance = nombre</synopsis>
          <para>Tolerance for <link linkend="gel-function-InfiniteSum"><function>InfiniteSum</function></link> and <link linkend="gel-function-InfiniteProduct"><function>InfiniteProduct</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SurfacePlotDrawLegends"/>SurfacePlotDrawLegends</term>
         <listitem>
          <synopsis>SurfacePlotDrawLegends = true</synopsis>
          <para>Tells genius to draw the legends for <link linkend="genius-gel-function-list-plotting">surface plotting
	  functions</link> such as <link linkend="gel-function-SurfacePlot"><function>SurfacePlot</function></link>.
          </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SurfacePlotVariableNames"/>SurfacePlotVariableNames</term>
         <listitem>
          <synopsis>SurfacePlotVariableNames = ["x","y","z"]</synopsis>
          <para>Tells genius which variable names are used as default names for <link linkend="genius-gel-function-list-plotting">surface plotting
	  functions</link> using <link linkend="gel-function-SurfacePlot"><function>SurfacePlot</function></link>.
          Note that the <varname>z</varname> does not refer to the dependent (vertical) axis, but to the independent complex variable
          <userinput>z=x+iy</userinput>.
          </para>
	  <para>Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SurfacePlotWindow"/>SurfacePlotWindow</term>
         <listitem>
          <synopsis>SurfacePlotWindow = [x1,x2,y1,y2,z1,z2]</synopsis>
          <para>Définit les limites pour les tracés de surface (consultez <link linkend="gel-function-SurfacePlot"><function>SurfacePlot</function></link>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorfieldNormalized"/>VectorfieldNormalized</term>
         <listitem>
          <synopsis>VectorfieldNormalized = true</synopsis>
          <para>Indique si les longueurs de flèches du tracé de champ de vecteurs doivent être normalisées. Si true (vrai), les tracés de champ de vecteurs n'affichent que la direction et pas l'amplitude (consultez <link linkend="gel-function-VectorfieldPlot"><function>VectorfieldPlot</function></link>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorfieldTicks"/>VectorfieldTicks</term>
         <listitem>
          <synopsis>VectorfieldTicks = [verticale,horizontale]</synopsis>
          <para>Définit le nombre de petits traits verticaux et horizontaux dans un graphique de champ de vecteurs (consultez <link linkend="gel-function-SlopefieldPlot"><function>VectorfieldPlot</function></link>).</para>
	  <para>Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-constants">
      <title>Constantes</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-CatalanConstant"/>CatalanConstant</term>
         <listitem>
          <synopsis>CatalanConstant</synopsis>
          <para>Constante de Catalan, approximativement 0,915..., elle est définie comme la série des termes <userinput>(-1^k)/((2*k+1)^2)</userinput> où <varname>k</varname> va de 0 à l'infini.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Catalan%27s_constant">Wikipedia</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/CatalansConstant.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-EulerConstant"/>EulerConstant</term>
         <listitem>
          <synopsis>EulerConstant</synopsis>
          <para>Alias : <function>gamma</function></para>
          <para>
	    Euler's constant gamma.  Sometimes called the
	    Euler-Mascheroni constant.
	  </para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Constante_d%27Euler-Mascheroni">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/MascheroniConstant.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Euler-MascheroniConstant.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-GoldenRatio"/>GoldenRatio</term>
         <listitem>
          <synopsis>GoldenRatio</synopsis>
          <para>Le nombre d'or.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Nombre_d%27or">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/GoldenRatio.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/GoldenRatio.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Gravity"/>Gravity</term>
         <listitem>
          <synopsis>Gravity</synopsis>
	  <para>Free fall acceleration at sea level in meters per second squared.  This is the standard gravity constant 9.80665.  The gravity
		  in your particular neck of the woods might be different due to different altitude and the fact that the earth is not perfectly
	  	  round and uniform.</para>
          <para>Consultez <ulink url="http://en.wikipedia.org/wiki/Standard_gravity">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-e"/>e</term>
         <listitem>
          <synopsis>e</synopsis>
          <para>
	    The base of the natural logarithm.  <userinput>e^x</userinput>
	    is the exponential function
	    <link linkend="gel-function-exp"><function>exp</function></link>.  It is approximately
	    2.71828182846...  This number is sometimes called Euler's number, although there are
	    several numbers that are also called Euler's.  An example is the gamma constant: <link linkend="gel-function-EulerConstant"><function>EulerConstant</function></link>.
	  </para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/E_%28nombre%29">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/E.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/e.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-pi"/>pi</term>
         <listitem>
          <synopsis>pi</synopsis>
          <para>Le nombre pi, c'est-à-dire le rapport de la circonférence d'un cercle sur son diamètre. Il vaut approximativement 3.14159265359...</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Pi">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/Pi.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Pi.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-numeric">
      <title>Nombres</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-AbsoluteValue"/>AbsoluteValue</term>
         <listitem>
          <synopsis>AbsoluteValue (x)</synopsis>
          <para>Alias : <function>abs</function></para>
          <para>
	    Absolute value of a number and if <varname>x</varname> is
	    a complex value the modulus of <varname>x</varname>.  I.e. this
	    the distance of <varname>x</varname> to the origin.  This is equivalent
	    to <userinput>|x|</userinput>.
	  </para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Valeur_absolue">Wikipedia</ulink>, <ulink url="http://planetmath.org/encyclopedia/AbsoluteValue.html">Planetmath (valeur absolue)</ulink>, <ulink url="http://planetmath.org/encyclopedia/ModulusOfComplexNumber.html">Planetmath (module)</ulink>, <ulink url="http://mathworld.wolfram.com/AbsoluteValue.html">Mathworld (valeur absolue)</ulink> ou <ulink url="http://mathworld.wolfram.com/ComplexModulus.html">Mathworld (module complexe)</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Chop"/>Chop</term>
         <listitem>
          <synopsis>Chop (x)</synopsis>
          <para>Remplace les très petits nombres par zéro.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ComplexConjugate"/>ComplexConjugate</term>
         <listitem>
          <synopsis>ComplexConjugate (z)</synopsis>
          <para>Alias : <function>conj</function> <function>Conj</function></para>
          <para>Calcule le conjugué du nombre complexe <varname>z</varname>. Si <varname>z</varname> est un vecteur ou une matrice, tous les éléments sont conjugués.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Conjugu%C3%A9">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Denominator"/>Denominator</term>
         <listitem>
          <synopsis>Denominator (x)</synopsis>
          <para>Renvoie le dénominateur d'un nombre rationnel.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/D%C3%A9nominateurr">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FractionalPart"/>FractionalPart</term>
         <listitem>
          <synopsis>FractionalPart (x)</synopsis>
          <para>Renvoie la partie fractionnelle d'un nombre.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Partie_fractionnaire">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Im"/>Im</term>
         <listitem>
          <synopsis>Im (z)</synopsis>
          <para>Alias : <function>ImaginaryPart</function></para>
          <para>Get the imaginary part of a complex number.  For example <userinput>Re(3+4i)</userinput> yields 4.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Partie_imaginaire">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IntegerQuotient"/>IntegerQuotient</term>
         <listitem>
          <synopsis>IntegerQuotient (m,n)</synopsis>
          <para>Division sans reste.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsComplex"/>IsComplex</term>
         <listitem>
          <synopsis>IsComplex (nbre)</synopsis>
	  <para>Check if argument is a complex (non-real) number.  Do note that we really mean nonreal number.  That is,
	  <userinput>IsComplex(3)</userinput> yields false, while
	  <userinput>IsComplex(3-1i)</userinput> yields true.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsComplexRational"/>IsComplexRational</term>
         <listitem>
          <synopsis>IsComplexRational (nbre)</synopsis>
	  <para>Vérifie si l'argument est potentiellement un nombre rationnel complexe. C'est-à-dire si la partie réelle et la partie imaginaire sont fournies sous la forme de nombres rationnels. Bien sûr, rationnel signifie simplement « non enregistré comme un nombre à virgule flottante ».</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsFloat"/>IsFloat</term>
         <listitem>
          <synopsis>IsFloat (nbre)</synopsis>
          <para>Check if argument is a real floating point number (non-complex).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsGaussInteger"/>IsGaussInteger</term>
         <listitem>
          <synopsis>IsGaussInteger (nbre)</synopsis>
          <para>Alias : <function>IsComplexInteger</function></para>
	  <para>Check if argument is a possibly complex integer.  That is a complex integer is a number of
		  the form <userinput>n+1i*m</userinput> where <varname>n</varname> and <varname>m</varname>
	  are integers.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsInteger"/>IsInteger</term>
         <listitem>
          <synopsis>IsInteger (nbre)</synopsis>
          <para>Vérifie si l'argument est un entier (non complexe).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsNonNegativeInteger"/>IsNonNegativeInteger</term>
         <listitem>
          <synopsis>IsNonNegativeInteger (nbre)</synopsis>
          <para>Check if argument is a non-negative real integer.  That is, either a positive integer or zero.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPositiveInteger"/>IsPositiveInteger</term>
         <listitem>
          <synopsis>IsPositiveInteger (nbre)</synopsis>
          <para>Alias : <function>IsNaturalNumber</function></para>
          <para>Vérifie si l'argument est un entier réel positif. Notez que par convention 0 n'est pas un nombre naturel.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsRational"/>IsRational</term>
         <listitem>
          <synopsis>IsRational (nbre)</synopsis>
          <para>Vérifie si l'argument est un nombre rationnel (non complexe). Bien sûr, rationnel signifie simplement « non enregistré comme un nombre à virgule flottante ».</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsReal"/>IsReal</term>
         <listitem>
          <synopsis>IsReal (nbre)</synopsis>
          <para>Vérifie si l'argument est un nombre réel.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Numerator"/>Numerator</term>
         <listitem>
          <synopsis>Numerator (x)</synopsis>
          <para>Renvoie le numérateur d'un nombre rationnel.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Num%C3%A9rateur">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Re"/>Re</term>
         <listitem>
          <synopsis>Re (z)</synopsis>
          <para>Alias : <function>RealPart</function></para>
	  <para>Get the real part of a complex number.  For example <userinput>Re(3+4i)</userinput> yields 3.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Partie_r%C3%A9elle">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Sign"/>Sign</term>
         <listitem>
          <synopsis>Sign (x)</synopsis>
          <para>Alias : <function>sign</function></para>
          <para>Renvoie le signe d'un nombre. C'est-à-dire renvoie <literal>-1</literal> si la valeur est négative, <literal>0</literal> si la valeur est nulle et <literal>1</literal> si la valeur est positive. Si <varname>x</varname> est une grandeur complexe alors <function>Sign</function> renvoie la direction ou 0.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ceil"/>ceil</term>
         <listitem>
          <synopsis>ceil (x)</synopsis>
          <para>Alias : <function>Ceiling</function></para>
	  <para>Get the lowest integer more than or equal to <varname>n</varname>. Examples:
          <screen><prompt>genius&gt;</prompt> <userinput>ceil(1.1)</userinput>
= 2
<prompt>genius&gt;</prompt> <userinput>ceil(-1.1)</userinput>
= -1
</screen>
           </para>
	   <para>Note that you should be careful and notice that floating point
		   numbers are stored an binary and so may not be what you
		   expect.  For example <userinput>ceil(420/4.2)</userinput>
		   returns 101 instead of the expected 100.  This is because
		   4.2 is actually very slightly less than 4.2.  Use rational
		   representation <userinput>42/10</userinput> if you want
		   exact arithmetic.
           </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-exp"/>exp</term>
         <listitem>
          <synopsis>exp (x)</synopsis>
          <para>La fonction exponentielle. C'est la fonction <userinput>e^x</userinput> où <varname>e</varname> est la <link linkend="gel-function-e">base du logarithme naturel</link>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Fonction_exponentielle">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/LogarithmFunction.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/ExponentialFunction.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-float"/>float</term>
         <listitem>
          <synopsis>float (x)</synopsis>
          <para>Transforme le nombre en nombre à virgule flottante. C'est-à-dire la représentation à virgule flottante du nombre <varname>x</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-floor"/>floor</term>
         <listitem>
          <synopsis>floor (x)</synopsis>
          <para>Alias : <function>Floor</function></para>
          <para>Renvoie le plus grand entier inférieur ou égal à <varname>n</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ln"/>ln</term>
         <listitem>
          <synopsis>ln (x)</synopsis>
          <para>Le logarithme naturel, le logarithme de base <varname>e</varname>.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Natural_logarithm">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/encyclopedia/LogarithmFunction.html">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/NaturalLogarithm.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-log"/>log</term>
         <listitem>
          <synopsis>log (x)</synopsis>
          <synopsis>log (x,b)</synopsis>
	  <para>Logarithm of <varname>x</varname> base <varname>b</varname> (calls <link linkend="gel-function-DiscreteLog"><function>DiscreteLog</function></link> if in modulo mode), if base is not given, <link linkend="gel-function-e"><varname>e</varname></link> is used.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-log10"/>log10</term>
         <listitem>
          <synopsis>log10 (x)</synopsis>
          <para>Logarithme base 10 de <varname>x</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-log2"/>log2</term>
         <listitem>
          <synopsis>log2 (x)</synopsis>
          <para>Alias : <function>lg</function></para>
          <para>Logarithme base 2 de <varname>x</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-max"/>max</term>
         <listitem>
          <synopsis>max (a,params...)</synopsis>
          <para>Alias : <function>Max</function> <function>Maximum</function></para>
          <para>Renvoie le maximum des arguments ou de la matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-min"/>min</term>
         <listitem>
          <synopsis>min (a,params...)</synopsis>
          <para>Alias : <function>Min</function> <function>Minimum</function></para>
          <para>Renvoie le minimum des arguments ou de la matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-rand"/>rand</term>
         <listitem>
          <synopsis>rand (taille...)</synopsis>
          <para>Génère aléatoirement des nombres flottants dans l'intervalle <literal>[0,1)</literal>. Si taille est donnée alors une matrice (si deux nombres sont fournis) ou un vecteur (si un seul est fourni) de la taille indiquée est renvoyé.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-randint"/>randint</term>
         <listitem>
          <synopsis>randint (max,taille...)</synopsis>
          <para>Génère aléatoirement des entiers dans l'intervalle <literal>[0,max)</literal>. Si taille est donné alors une matrice (si deux nombres sont fournis) ou un vecteur (si un seul est fourni) de la taille indiquée est renvoyé. Par exemple, <screen><prompt>genius&gt;</prompt> <userinput>randint(4)</userinput>
= 3
<prompt>genius&gt;</prompt> <userinput>randint(4,2)</userinput>
=
[0      1]
<prompt>genius&gt;</prompt> <userinput>randint(4,2,3)</userinput>
=
[2      2       1
 0      0       3]
</screen></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-round"/>round</term>
         <listitem>
          <synopsis>round (x)</synopsis>
          <para>Alias : <function>Round</function></para>
          <para>Arrondit un nombre.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-sqrt"/>sqrt</term>
         <listitem>
          <synopsis>sqrt (x)</synopsis>
          <para>Alias : <function>SquareRoot</function></para>
          <para>La racine carrée. Au cours de calculs en mode modulaire, certains entiers renvoient soit <constant>null</constant> ou un vecteur contenant les racines carrées. Exemples : <screen><prompt>genius&gt;</prompt> <userinput>sqrt(2)</userinput>
= 1.41421356237
<prompt>genius&gt;</prompt> <userinput>sqrt(-1)</userinput>
= 1i
<prompt>genius&gt;</prompt> <userinput>sqrt(4) mod 7</userinput>
=
[2      5]
<prompt>genius&gt;</prompt> <userinput>2*2 mod 7</userinput>
= 4
</screen></para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/SquareRoot.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-trunc"/>trunc</term>
         <listitem>
          <synopsis>trunc (x)</synopsis>
          <para>Alias : <function>Truncate</function><function>IntegerPart</function></para>
          <para>Tronque le nombre à un entier (renvoie la partie entière).</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-trigonometry">
      <title>Trigonométrie</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-acos"/>acos</term>
         <listitem>
          <synopsis>acos (x)</synopsis>
          <para>Alias : <function>arccos</function></para>
          <para>Fonction arccos (arc cosinus).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-acosh"/>acosh</term>
         <listitem>
          <synopsis>acosh (x)</synopsis>
          <para>Alias : <function>arccosh</function></para>
          <para>Fonction arccosh (cosinus hyperbolique inverse).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-acot"/>acot</term>
         <listitem>
          <synopsis>acot (x)</synopsis>
          <para>Alias : <function>arccot</function></para>
          <para>Fonction arccot (cotangente inverse).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-acoth"/>acoth</term>
         <listitem>
          <synopsis>acoth (x)</synopsis>
          <para>Alias : <function>arccoth</function></para>
          <para>Fonction arccoth (cotangente hyperbolique inverse).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-acsc"/>acsc</term>
         <listitem>
          <synopsis>acsc (x)</synopsis>
          <para>Alias : <function>arccsc</function></para>
          <para>Inverse de la fonction cosécante.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-acsch"/>acsch</term>
         <listitem>
          <synopsis>acsch (x)</synopsis>
          <para>Alias : <function>arccsch</function></para>
          <para>Inverse de la fonction cosécante hyperbolique.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-asec"/>asec</term>
         <listitem>
          <synopsis>asec (x)</synopsis>
          <para>Alias : <function>arcsec</function></para>
          <para>Inverse de la fonction sécante.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-asech"/>asech</term>
         <listitem>
          <synopsis>asech (x)</synopsis>
          <para>Alias : <function>arcsech</function></para>
          <para>Inverse de la fontion sécante hyperbolique.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-asin"/>asin</term>
         <listitem>
          <synopsis>asin (x)</synopsis>
          <para>Alias : <function>arcsin</function></para>
          <para>La fonction arcsin (sinus inverse).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-asinh"/>asinh</term>
         <listitem>
          <synopsis>asinh (x)</synopsis>
          <para>Alias : <function>arcsinh</function></para>
          <para>Fonction arcsinh (sinus hyperbolique inverse).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-atan"/>atan</term>
         <listitem>
          <synopsis>atan (x)</synopsis>
          <para>Alias : <function>arctan</function></para>
          <para>Calcule la fonction arctangente (tangente inverse).</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Arctangente">Wikipedia</ulink> or <ulink url="http://mathworld.wolfram.com/InverseTangent.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-atanh"/>atanh</term>
         <listitem>
          <synopsis>atanh (x)</synopsis>
          <para>Alias : <function>arctanh</function></para>
          <para>Fonction arctanh (tangente hyperbolique inverse).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-atan2"/>atan2</term>
         <listitem>
          <synopsis>atan2 (y, x)</synopsis>
          <para>Alias : <function>arctan2</function></para>
          <para>Calcule la fonction arctan2. Si <userinput>x&gt;0</userinput> alors renvoie <userinput>atan(y/x)</userinput>. Si <userinput>x&lt;0</userinput> alors cela renvoie <userinput>sign(y) * (pi - atan(|y/x|)</userinput>. Si <userinput>x=0</userinput> cela renvoie <userinput>sign(y) *
	  pi/2</userinput>. <userinput>atan2(0,0)</userinput> renvoie 0 plutôt que d'échouer.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Atan2">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/InverseTangent.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-cos"/>cos</term>
         <listitem>
          <synopsis>cos (x)</synopsis>
          <para>Calcule la fonction cosinus.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/DefinitionsInTrigonometry.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-cosh"/>cosh</term>
         <listitem>
          <synopsis>cosh (x)</synopsis>
          <para>Calcule la fonction cosinus hyperbolique.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HyperbolicFunctions.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-cot"/>cot</term>
         <listitem>
          <synopsis>cot (x)</synopsis>
          <para>Fonction cotangente.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/DefinitionsInTrigonometry.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-coth"/>coth</term>
         <listitem>
          <synopsis>coth (x)</synopsis>
          <para>Fonction cotangente hyperbolique.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HyperbolicFunctions.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-csc"/>csc</term>
         <listitem>
          <synopsis>csc (x)</synopsis>
          <para>Fonction cosécante.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/DefinitionsInTrigonometry.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-csch"/>csch</term>
         <listitem>
          <synopsis>csch (x)</synopsis>
          <para>Fonction cosécante hyperbolique.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HyperbolicFunctions.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-sec"/>sec</term>
         <listitem>
          <synopsis>sec (x)</synopsis>
          <para>Fonction sécante.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/DefinitionsInTrigonometry.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-sech"/>sech</term>
         <listitem>
          <synopsis>sech (x)</synopsis>
          <para>Fonction sécante hyperbolique.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HyperbolicFunctions.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-sin"/>sin</term>
         <listitem>
          <synopsis>sin (x)</synopsis>
          <para>Calcule la fonction sinus.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/DefinitionsInTrigonometry.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-sinh"/>sinh</term>
         <listitem>
          <synopsis>sinh (x)</synopsis>
          <para>Calcule la fonction sinus hyperbolique.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HyperbolicFunctions.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-tan"/>tan</term>
         <listitem>
          <synopsis>tan (x)</synopsis>
          <para>Calcule la fonction tangente.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/DefinitionsInTrigonometry.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-tanh"/>tanh</term>
         <listitem>
          <synopsis>tanh (x)</synopsis>
          <para>Fonction tangente hyperbolique.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HyperbolicFunctions.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-number-theory">
      <title>Théorie des nombres</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-AreRelativelyPrime"/>AreRelativelyPrime</term>
         <listitem>
          <synopsis>AreRelativelyPrime (a,b)</synopsis>
          <para>Si les entiers <varname>a</varname> et <varname>b</varname> sont premiers entre eux ? Renvoie <constant>true</constant> (vrai) ou <constant>false</constant> (faux).</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/RelativelyPrime.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/RelativelyPrime.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BernoulliNumber"/>BernoulliNumber</term>
         <listitem>
          <synopsis>BernoulliNumber (n)</synopsis>
          <para>Renvoie le <varname>n</varname>-ième nombre de Bernoulli.</para>
          <para>Consultez <ulink url="http://en.wikipedia.org/wiki/Bernoulli_number">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/BernoulliNumber.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ChineseRemainder"/>ChineseRemainder</term>
         <listitem>
          <synopsis>ChineseRemainder (a,m)</synopsis>
          <para>Alias : <function>CRT</function></para>
	  <para>Recherche <varname>x</varname> qui résout le système défini par le vecteur <varname>a</varname> et modulo les éléments de <varname>m</varname>, en utilisant le théorème des restes chinois.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_restes_chinois">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/ChineseRemainderTheorem.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/ChineseRemainderTheorem.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CombineFactorizations"/>CombineFactorizations</term>
         <listitem>
          <synopsis>CombineFactorizations (a,b)</synopsis>
	  <para>Étant donné deux factorisations, donne la factorisation du produit.</para>
	  <para>Consultez <link linkend="gel-function-Factorize">Factorize</link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ConvertFromBase"/>ConvertFromBase</term>
         <listitem>
          <synopsis>ConvertFromBase (v,b)</synopsis>
          <para>Convertit un vecteur de valeurs indiquant les puissances de b en un nombre.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ConvertToBase"/>ConvertToBase</term>
         <listitem>
          <synopsis>ConvertToBase (n,b)</synopsis>
          <para>Convertit un nombre en un vecteur contenant les puissances des éléments dans la base <varname>b</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DiscreteLog"/>DiscreteLog</term>
         <listitem>
          <synopsis>DiscreteLog (n,b,q)</synopsis>
          <para>Calcule le logarithme discret de <varname>n</varname> base <varname>b</varname> dans F<subscript>q</subscript>, le corps fini d'ordre <varname>q</varname> où <varname>q</varname> est un nombre premier, en utilisant l'algorithme de Silver-Pohlig-Hellman.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Logarithme_discret">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/DiscreteLogarithm.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/DiscreteLogarithm.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Divides"/>Divides</term>
         <listitem>
          <synopsis>Divides (m,n)</synopsis>
          <para>Vérifie la divisibilité (si <varname>m</varname> divise <varname>n</varname>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-EulerPhi"/>EulerPhi</term>
         <listitem>
          <synopsis>EulerPhi (n)</synopsis>
          <para>Calcule la fonction d'Euler phi, c'est-à-dire le nombre d'entiers compris entre 1 et <varname>n</varname> qui sont premiers avec <varname>n</varname>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Indicatrice_d%27Euler">Wikipedia</ulink> or <ulink url="http://planetmath.org/encyclopedia/EulerPhifunction.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/TotientFunction.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ExactDivision"/>ExactDivision</term>
         <listitem>
          <synopsis>ExactDivision (n,d)</synopsis>
          <para>Renvoie <userinput>n/d</userinput> mais seulement si <varname>d</varname> divise <varname>n</varname>. Si <varname>d</varname> ne divise pas <varname>n</varname> alors cette fonction ne renvoie rien d'utile. Cette fonction est beaucoup plus rapide pour les très grands nombres que l'opération <userinput>n/d</userinput>, mais bien sûr utile seulement si vous savez que la division est exacte.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Factorize"/>Factorize</term>
         <listitem>
          <synopsis>Factorize (n)</synopsis>
          <para>Renvoie la factorisation d'un nombre sous la forme d'une matrice. La première ligne contient les nombres premiers dans la factorisation (y compris 1) et la seconde ligne sont les puissances. Par exemple : <screen><prompt>genius&gt;</prompt> <userinput>Factorize(11*11*13)</userinput>
=
[1      11      13
 1      2       1]</screen></para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Factorisation">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Factors"/>Factors</term>
         <listitem>
          <synopsis>Factors (n)</synopsis>
          <para>Renvoie tous les facteurs de <varname>n</varname> dans un vecteur. Cela inclut tous les facteurs non premiers également mais aussi 1 et le nombre lui-même. Ainsi par exemple pour afficher tous les nombres parfaits (ceux qui sont la somme de leurs facteurs) jusqu'au nombre 1000, vous pouvez écrire (ce n'est bien sûr pas efficace) : <programlisting>for n=1 to 1000 do (
    if MatrixSum (Factors(n)) == 2*n then
        print(n)
)
</programlisting></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FermatFactorization"/>FermatFactorization</term>
         <listitem>
          <synopsis>FermatFactorization (n,tentatives)</synopsis>
          <para>
	    Attempt Fermat factorization of <varname>n</varname> into
	    <userinput>(t-s)*(t+s)</userinput>, returns <varname>t</varname>
	    and <varname>s</varname> as a vector if possible, <constant>null</constant> otherwise.
	    <varname>tries</varname> specifies the number of tries before
	    giving up.
	  </para>
          <para>C'est une assez bonne factorisation si votre nombre est le produit de deux facteurs très proches l'un de l'autre.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/M%C3%A9thode_de_factorisation_de_Fermat">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FindPrimitiveElementMod"/>FindPrimitiveElementMod</term>
         <listitem>
          <synopsis>FindPrimitiveElementMod (q)</synopsis>
          <para>Cherche le premier élément primitif dans F<subscript>q</subscript>, le groupe fini d'ordre <varname>q</varname>. Bien sûr, <varname>q</varname> doit être premier.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FindRandomPrimitiveElementMod"/>FindRandomPrimitiveElementMod</term>
         <listitem>
          <synopsis>FindRandomPrimitiveElementMod (q)</synopsis>
          <para>Cherche un élément primitif au hasard dans F<subscript>q</subscript>, le groupe fini d'ordre <varname>q</varname> (q doit être premier).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IndexCalculus"/>IndexCalculus</term>
         <listitem>
          <synopsis>IndexCalculus (n,b,q,S)</synopsis>
          <para>Compute discrete log base <varname>b</varname> of n in F<subscript>q</subscript>, the finite
group of order <varname>q</varname> (<varname>q</varname> a prime), using the
factor base <varname>S</varname>.  <varname>S</varname> should be a column of
primes possibly with second column precalculated by
<link linkend="gel-function-IndexCalculusPrecalculation"><function>IndexCalculusPrecalculation</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IndexCalculusPrecalculation"/>IndexCalculusPrecalculation</term>
         <listitem>
          <synopsis>IndexCalculusPrecalculation (b,q,S)</synopsis>
	  <para>Run the precalculation step of
		  <link linkend="gel-function-IndexCalculus"><function>IndexCalculus</function></link> for logarithms base <varname>b</varname> in
F<subscript>q</subscript>, the finite group of order <varname>q</varname>
(<varname>q</varname> a prime), for the factor base <varname>S</varname> (where
<varname>S</varname> is a column vector of primes).  The logs will be
precalculated and returned in the second column.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsEven"/>IsEven</term>
         <listitem>
          <synopsis>IsEven (n)</synopsis>
          <para>Teste si un entier est pair.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsMersennePrimeExponent"/>IsMersennePrimeExponent</term>
         <listitem>
          <synopsis>IsMersennePrimeExponent (p)</synopsis>
          <para>
	    Tests if a positive integer <varname>p</varname> is a
	    Mersenne prime exponent.  That is if 
            2<superscript>p</superscript>-1 is a prime.  It does this
	    by looking it up in a table of known values, which is relatively
	    short.
	    See also
	    <link linkend="gel-function-MersennePrimeExponents">MersennePrimeExponents</link>
	    and
	    <link linkend="gel-function-LucasLehmer">LucasLehmer</link>.
	  </para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Nombre_premier_de_Mersenne">Wikipedia</ulink>, <ulink url="http://planetmath.org/encyclopedia/MersenneNumbers.html">Planetmath</ulink>, <ulink url="http://mathworld.wolfram.com/MersennePrime.html">Mathworld</ulink> ou <ulink url="http://www.mersenne.org/">GIMPS</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsNthPower"/>IsNthPower</term>
         <listitem>
          <synopsis>IsNthPower (m,n)</synopsis>
          <para>Vérifie si un nombre rationnel <varname>m</varname> est une puissance <varname>n</varname>-ième parfaite. Consultez aussi <link linkend="gel-function-IsPerfectPower">IsPerfectPower</link> et <link linkend="gel-function-IsPerfectSquare">IsPerfectSquare</link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsOdd"/>IsOdd</term>
         <listitem>
          <synopsis>IsOdd (n)</synopsis>
          <para>Teste si un entier est impair.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPerfectPower"/>IsPerfectPower</term>
         <listitem>
          <synopsis>IsPerfectPower (n)</synopsis>
          <para>Vérifie qu'un entier est une puissance parfaite, a<superscript>b</superscript>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPerfectSquare"/>IsPerfectSquare</term>
         <listitem>
          <synopsis>IsPerfectSquare (n)</synopsis>
          <para>Vérifie qu'un entier est un carré parfait d'un entier. Le nombre doit être un vrai entier. Les entiers négatifs ne peuvent bien sûr jamais être des carrés de vrais entiers.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPrime"/>IsPrime</term>
         <listitem>
          <synopsis>IsPrime (n)</synopsis>
          <para>Teste la primalité des entiers ; pour les nombres inférieurs à 2,5e10 la réponse est déterministe (si l'hypothèse de Riemann est vérifiée). Pour des nombres plus grands, la probabilité d'une erreur de détermination dépend du paramètre <link linkend="gel-function-IsPrimeMillerRabinReps"><function>IsPrimeMillerRabinReps</function></link>. C'est-à-dire la probabilité d'une erreur de détermination vaut 1/4 à la puissance <function>IsPrimeMillerRabinReps</function>. La valeur par défaut de 22 mène à une probabilité d'environ 5.7e-14.</para>
          <para>Si <constant>false</constant> (faux) est renvoyé, vous êtes sûr que le nombre est composé. Si vous voulez être absolument certain d'avoir un nombre premier vous pouvez utiliser la fonction <link linkend="gel-function-MillerRabinTestSure"><function>MillerRabinTestSure</function></link> mais cela peut prendre beaucoup plus de temps.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/PrimeNumber.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/PrimeNumber.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPrimitiveMod"/>IsPrimitiveMod</term>
         <listitem>
          <synopsis>IsPrimitiveMod (g,q)</synopsis>
          <para>Vérifie que <varname>g</varname> est primitif dans F<subscript>q</subscript>, le groupe fini d'ordre <varname>q</varname>, où <varname>q</varname> est premier. Si <varname>q</varname> n'est pas premier, les résultats sont erronés.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPrimitiveModWithPrimeFactors"/>IsPrimitiveModWithPrimeFactors</term>
         <listitem>
          <synopsis>IsPrimitiveModWithPrimeFactors (g,q,f)</synopsis>
          <para>Vérifie que <varname>g</varname> est primitif dans F<subscript>q</subscript>, le groupe fini d'ordre <varname>q</varname>, où <varname>q</varname> est premier et <varname>f</varname> est un vecteur de facteurs premiers de <varname>q</varname>-1. Si <varname>q</varname> n'est pas premier, les résultats sont erronés.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPseudoprime"/>IsPseudoprime</term>
         <listitem>
          <synopsis>IsPseudoprime (n,b)</synopsis>
          <para>If <varname>n</varname> is a pseudoprime base <varname>b</varname> but not a prime,
		  that is if <userinput>b^(n-1) == 1 mod n</userinput>.  This calls the <link linkend="gel-function-PseudoprimeTest"><function>PseudoprimeTest</function></link></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsStrongPseudoprime"/>IsStrongPseudoprime</term>
         <listitem>
          <synopsis>IsStrongPseudoprime (n,b)</synopsis>
          <para>Teste si <varname>n</varname> est un nombre pseudopremier fort en base <varname>b</varname> mais pas un nombre premier.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Jacobi"/>Jacobi</term>
         <listitem>
          <synopsis>Jacobi (a,b)</synopsis>
          <para>Alias : <function>JacobiSymbol</function></para>
          <para>Calcule le symbole de Jacobi (a/b) (b doit être impair).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-JacobiKronecker"/>JacobiKronecker</term>
         <listitem>
          <synopsis>JacobiKronecker (a,b)</synopsis>
          <para>Alias : <function>JacobiKroneckerSymbol</function></para>
          <para>Calcule le symbole de Jacobi (a/b) avec l'extension de Kronecker (a/2)=(2/a) si impair, ou (a/2)=0 si pair.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LeastAbsoluteResidue"/>LeastAbsoluteResidue</term>
         <listitem>
          <synopsis>LeastAbsoluteResidue (a,n)</synopsis>
          <para>Renvoie le résidu de <varname>a</varname> modulo <varname>n</varname> avec la plus petite valeur absolue (entre -n/2 et n/2).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Legendre"/>Legendre</term>
         <listitem>
          <synopsis>Legendre (a,p)</synopsis>
          <para>Alias : <function>LegendreSymbol</function></para>
          <para>Calcule le symbole de Legendre (a/p).</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/LegendreSymbol.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/LegendreSymbol.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LucasLehmer"/>LucasLehmer</term>
         <listitem>
          <synopsis>LucasLehmer (p)</synopsis>
          <para>Teste si 2<superscript>p</superscript>-1 est un nombre premier de Mersenne en utilisant le test de Lucas-Lehmer. Consultez aussi <link linkend="gel-function-MersennePrimeExponents">MersennePrimeExponents</link> et <link linkend="gel-function-IsMersennePrimeExponent">IsMersennePrimeExponent</link>.</para>
          <para>Consultez <ulink url="http://http://fr.wikipedia.org/wiki/Test_de_primalit%C3%A9_de_Lucas-Lehmer_pour_les_nombres_de_Mersenne">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/LucasLhemer.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Lucas-LehmerTest.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LucasNumber"/>LucasNumber</term>
         <listitem>
          <synopsis>LucasNumber (n)</synopsis>
          <para>Renvoie le <varname>n</varname>-ième nombre de Lucas.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Nombre_de_Lucas">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/LucasNumbers.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/LucasNumber.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MaximalPrimePowerFactors"/>MaximalPrimePowerFactors</term>
         <listitem>
          <synopsis>MaximalPrimePowerFactors (n)</synopsis>
          <para>Renvoie les puissances premières d'un nombre.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MersennePrimeExponents"/>MersennePrimeExponents</term>
         <listitem>
          <synopsis>MersennePrimeExponents</synopsis>
          <para>Renvoie un vecteur de nombres premiers de Mersenne qui est une liste d'entiers positifs <varname>p</varname> tels que 2<superscript>p</superscript>-1 est entier. Consultez aussi <link linkend="gel-function-IsMersennePrimeExponent">IsMersennePrimeExponent</link> et <link linkend="gel-function-LucasLehmer">LucasLehmer</link>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Nombre_premier_de_Mersenne">Wikipedia</ulink>, <ulink url="http://planetmath.org/encyclopedia/MersenneNumbers.html">Planetmath</ulink>, <ulink url="http://mathworld.wolfram.com/MersennePrime.html">Mathworld</ulink> ou <ulink url="http://www.mersenne.org/">GIMPS</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MillerRabinTest"/>MillerRabinTest</term>
         <listitem>
          <synopsis>MillerRabinTest (n,reps)</synopsis>
          <para>Utilise le test de primalité de Miller-Rabin sur <varname>n</varname>, en faisant <varname>reps</varname> essais. La probabilité d'une erreur de détermination est <userinput>(1/4)^reps</userinput>. Il est probablement préférable d'utiliser la fonction <link linkend="gel-function-IsPrime"><function>IsPrime</function></link> puisqu'elle est plus rapide et meilleure pour les entiers les plus petits.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Test_de_primalit%C3%A9_de_Miller-Rabin">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/MillerRabinPrimeTest.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Rabin-MillerStrongPseudoprimeTest.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MillerRabinTestSure"/>MillerRabinTestSure</term>
         <listitem>
          <synopsis>MillerRabinTestSure (n)</synopsis>
          <para>
	    Use the Miller-Rabin primality test on <varname>n</varname> with
	    enough bases that assuming the Generalized Riemann Hypothesis the
	    result is deterministic.
	  </para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Test_de_primalit%C3%A9_de_Miller-Rabin">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/MillerRabinPrimeTest.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Rabin-MillerStrongPseudoprimeTest.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ModInvert"/>ModInvert</term>
         <listitem>
          <synopsis>ModInvert (n,m)</synopsis>
          <para>Renvoie l'inverse de n mod m.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/ModularInverse.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MoebiusMu"/>MoebiusMu</term>
         <listitem>
          <synopsis>MoebiusMu (n)</synopsis>
          <para>Renvoie la fonction mu de Moebius évaluée dans <varname>n</varname>. C'est-à-dire renvoie 0 si <varname>n</varname> n'est pas un produit de nombres premiers différents et <userinput>(-1)^k</userinput> si c'est un produit de <varname>k</varname> nombres premiers différents.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/MoebiusFunction.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/MoebiusFunction.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NextPrime"/>NextPrime</term>
         <listitem>
          <synopsis>NextPrime (n)</synopsis>
          <para>Renvoie le plus petit nombre premier supérieur à <varname>n</varname>. L'opposé d'un nombre premier est considéré comme un nombre premier donc pour obtenir le nombre premier précédent, vous pouvez utiliser <userinput>-NextPrime(-n)</userinput>.</para>
          <para>
	    This function uses the GMPs <function>mpz_nextprime</function>,
	    which in turn uses the probabilistic Miller-Rabin test
	    (See also <link linkend="gel-function-MillerRabinTest"><function>MillerRabinTest</function></link>).
	    The probability
	    of false positive is not tunable, but is low enough
	    for all practical purposes.
	  </para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/PrimeNumber.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/PrimeNumber.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PadicValuation"/>PadicValuation</term>
         <listitem>
          <synopsis>PadicValuation (n,p)</synopsis>
          <para>Renvoie la valuation p-adic (nombre de zéros après la virgule en base <varname>p</varname>).</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/PAdicValuation.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PowerMod"/>PowerMod</term>
         <listitem>
          <synopsis>PowerMod (a,b,m)</synopsis>
          <para>
	    Compute <userinput>a^b mod m</userinput>.  The
	    <varname>b</varname>'s power of <varname>a</varname> modulo
	    <varname>m</varname>.  It is not necessary to use this function
	    as it is automatically used in modulo mode.  Hence
	    <userinput>a^b mod m</userinput> is just as fast.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Prime"/>Prime</term>
         <listitem>
          <synopsis>Prime (n)</synopsis>
          <para>Alias : <function>prime</function></para>
          <para>Renvoie le <varname>n</varname>-ième nombre premier (jusqu'à une limite) .</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/PrimeNumber.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/PrimeNumber.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PrimeFactors"/>PrimeFactors</term>
         <listitem>
          <synopsis>PrimeFactors (n)</synopsis>
          <para>Renvoie tous les facteurs premiers d'un nombre sous la forme d'un vecteur.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/PrimeFactor.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PseudoprimeTest"/>PseudoprimeTest</term>
         <listitem>
          <synopsis>PseudoprimeTest (n,b)</synopsis>
	  <para>Test de pseudoprimalité, renvoie <constant>true</constant> (vrai) si et seulement si <userinput>b^(n-1) == 1  mod n</userinput></para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/Pseudoprime.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Pseudoprime.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RemoveFactor"/>RemoveFactor</term>
         <listitem>
          <synopsis>RemoveFactor (n,m)</synopsis>
          <para>Supprime toutes les instances du facteur <varname>m</varname> dans le nombre <varname>n</varname>. C'est-à-dire divise par la plus grande puissance de <varname>m</varname> qui divise <varname>n</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/Divisibility.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Factor.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SilverPohligHellmanWithFactorization"/>SilverPohligHellmanWithFactorization</term>
         <listitem>
          <synopsis>SilverPohligHellmanWithFactorization (n,b,q,f)</synopsis>
          <para>Calcule le logarithme discret de <varname>n</varname> base <varname>b</varname> dans F<subscript>q</subscript>, le corps fini d'ordre <varname>q</varname> où <varname>q</varname> est un nombre premier, en utilisant l'algorithme de Silver-Pohlig-Hellman, sachant que <varname>f</varname> est la factorisation de <varname>q</varname>-1.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SqrtModPrime"/>SqrtModPrime</term>
         <listitem>
          <synopsis>SqrtModPrime (n,p)</synopsis>
          <para>Cherche la racine carrée de <varname>n</varname> modulo <varname>p</varname> (où <varname>p</varname> est premier). <constant>null</constant> est renvoyé si ce n'est pas un résidu quadratique.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/QuadraticResidue.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/QuadraticResidue.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-StrongPseudoprimeTest"/>StrongPseudoprimeTest</term>
         <listitem>
          <synopsis>StrongPseudoprimeTest (n,b)</synopsis>
          <para>Lance le test de pseudo-primarité forte en base <varname>b</varname> sur <varname>n</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/StrongPseudoprime.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/StrongPseudoprime.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-gcd"/>gcd</term>
         <listitem>
          <synopsis>gcd (a,params...)</synopsis>
          <para>Alias : <function>GCD</function></para>
          <para>Plus grand commun diviseur d'entiers (PGCD, en anglais « Greatest Common Divisor »). Vous pouvez fournir autant d'entiers que vous voulez dans la liste d'arguments ou vous pouvez fournir un vecteur ou une matrice d'entiers. Si vous fournissez plus d'une matrice de la même taille alors le PGCD est recherché élément par élément.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/GreatestCommonDivisor.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/GreatestCommonDivisor.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-lcm"/>lcm</term>
         <listitem>
          <synopsis>lcm (a,params...)</synopsis>
          <para>Alias : <function>LCM</function></para>
          <para>Plus petit commun multiple d'entiers (PPCM, en anglais « Least Common Multiplier »). Vous pouvez fournir autant d'entiers que vous voulez dans la liste d'arguments ou vous pouvez fournir un vecteur ou une matrice d'entiers. Si vous fournissez plus d'une matrice de la même taille alors le PPCM est recherché élément par élément.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/LeastCommonMultiple.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/LeastCommonMultiple.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-matrix">
      <title>Manipulation de matrices</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-ApplyOverMatrix"/>ApplyOverMatrix</term>
         <listitem>
          <synopsis>ApplyOverMatrix (a,fonc)</synopsis>
          <para>Applique une fonction sur tous les éléments d'une matrice et renvoie une matrice de résultats.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ApplyOverMatrix2"/>ApplyOverMatrix2</term>
         <listitem>
          <synopsis>ApplyOverMatrix2 (a,b,fonc)</synopsis>
          <para>Applique une fonction sur tous les éléments de 2 matrices (ou 1 valeur et 1 matrice) et renvoie une matrice de résultats.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ColumnsOf"/>ColumnsOf</term>
         <listitem>
          <synopsis>ColumnsOf (M)</synopsis>
          <para>Extrait les colonnes de la matrice comme un vecteur horizontal.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ComplementSubmatrix"/>ComplementSubmatrix</term>
         <listitem>
          <synopsis>ComplementSubmatrix (m,r,c)</synopsis>
          <para>Supprime certaines lignes et colonnes d'une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CompoundMatrix"/>CompoundMatrix</term>
         <listitem>
          <synopsis>CompoundMatrix (k,A)</synopsis>
          <para>Calcule la k-ième matrice composée de A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CountZeroColumns"/>CountZeroColumns</term>
         <listitem>
          <synopsis>CountZeroColumns (M)</synopsis>
          <para>
	   Count the number of zero columns in a matrix.  For example
	   once your column reduce a matrix you can use this to find
	   the nullity.  See <link linkend="gel-function-cref"><function>cref</function></link>
	   and <link linkend="gel-function-Nullity"><function>Nullity</function></link>.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DeleteColumn"/>DeleteColumn</term>
         <listitem>
          <synopsis>DeleteColumn (M,col)</synopsis>
          <para>Supprime une colonne d'une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DeleteRow"/>DeleteRow</term>
         <listitem>
          <synopsis>DeleteRow (M,row)</synopsis>
          <para>Supprime une ligne d'une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DiagonalOf"/>DiagonalOf</term>
         <listitem>
          <synopsis>DiagonalOf (M)</synopsis>
          <para>Extrait la diagonale de la matrice comme un vecteur colonne.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Diagonale">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DotProduct"/>DotProduct</term>
         <listitem>
          <synopsis>DotProduct (u,v)</synopsis>
	  <para>Renvoie le produit scalaire de deux vecteurs. Les vecteurs doivent être de même taille. Aucune conjugaison n'est faite donc c'est une forme bilinéaire même dans le cas de nombres complexes.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/DotProduct.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ExpandMatrix"/>ExpandMatrix</term>
         <listitem>
          <synopsis>ExpandMatrix (M)</synopsis>
          <para>Développe une matrice exactement comme cela est fait lors de la saisie d'une matrice non précédée d'une apostrophe. Cela signifie que toute matrice interne est développée sous la forme de blocs. C'est une façon de construire des matrices à partir de matrices plus petites et c'est ce qui est effectué normalement de manière automatique lors d'une saisie à moins que la matrice ne soit précédée d'une apostrophe.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-HermitianProduct"/>HermitianProduct</term>
         <listitem>
          <synopsis>HermitianProduct (u,v)</synopsis>
          <para>Alias : <function>InnerProduct</function></para>
          <para>Renvoie le produit hermitienne de deux vecteurs. Les vecteurs doivent avoir la même taille. C'est une forme sesquilinéaire utilisant la matrice identité.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/HermitianInnerProduct.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-I"/>I</term>
         <listitem>
          <synopsis>I (n)</synopsis>
          <para>Alias : <function>eye</function></para>
	  <para>Renvoie une matrice identité de la taille indiquée, soit une matrice de <varname>n</varname> par <varname>n</varname>. Si <varname>n</varname> vaut zéro, renvoie <constant>null</constant>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/IdentityMatrix.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IndexComplement"/>IndexComplement</term>
         <listitem>
          <synopsis>IndexComplement (vec,mtaille)</synopsis>
          <para>Renvoie le complémentaire d'un vecteur d'indices. Le premier indice est toujours 1. Par exemple pour le vecteur <userinput>[2,3]</userinput> et la taille <userinput>5</userinput>, cela renvoie <userinput>[1,4,5]</userinput>. Si <varname>mtaille</varname> vaut 0, cela renvoie toujours <constant>null</constant>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsDiagonal"/>IsDiagonal</term>
         <listitem>
          <synopsis>IsDiagonal (M)</synopsis>
          <para>Indique si la matrice est diagonale.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Matrice_diagonale">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/DiagonalMatrix.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsIdentity"/>IsIdentity</term>
         <listitem>
          <synopsis>IsIdentity (x)</synopsis>
          <para>Vérifie qu'une matrice est la matrice identité. Renvoie automatiquement <constant>false</constant> (faux) si la matrice n'est pas carrée. Fonctionne également avec les nombres et dans ce cas, c'est équivalent à <userinput>x==1</userinput>. Lorsque <varname>x</varname> est <constant>null</constant>, il est considéré comme une matrice 0 par 0, aucune erreur n'est générée et <constant>false</constant> (faux) est renvoyé.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsLowerTriangular"/>IsLowerTriangular</term>
         <listitem>
          <synopsis>IsLowerTriangular (M)</synopsis>
          <para>Indique si une matrice est triangulaire inférieure, c'est-à-dire que toutes les valeurs au dessus de la diagonale sont nulles.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsMatrixInteger"/>IsMatrixInteger</term>
         <listitem>
          <synopsis>IsMatrixInteger (M)</synopsis>
          <para>Vérifie si une matrice est constituée de nombres entiers (non complexe).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsMatrixNonnegative"/>IsMatrixNonnegative</term>
         <listitem>
          <synopsis>IsMatrixNonnegative (M)</synopsis>
          <para>Vérifie si une matrice est non négative, c'est-à-dire que chaque élément n'est pas négatif. Ne pas confondre les matrices positives avec les matrices définies positives.</para>
          <para>Consultez <ulink url="http://en.wikipedia.org/wiki/Positive_matrix">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsMatrixPositive"/>IsMatrixPositive</term>
         <listitem>
          <synopsis>IsMatrixPositive (M)</synopsis>
	  <para>Vérifie si une matrice est positive, c'est-à-dire que chaque élément est positif (et par conséquent réel), et en particulier qu'aucun élément n'est nul. Ne pas confondre les matrices positives avec les matrices définies positives</para>
          <para>Consultez <ulink url="http://en.wikipedia.org/wiki/Positive_matrix">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsMatrixRational"/>IsMatrixRational</term>
         <listitem>
          <synopsis>IsMatrixRational (M)</synopsis>
          <para>Vérifie si une matrice est constituée de nombres rationnels (non complexes).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsMatrixReal"/>IsMatrixReal</term>
         <listitem>
          <synopsis>IsMatrixReal (M)</synopsis>
          <para>Vérifie si une matrice est constituée de nombres réels (non complexes).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsMatrixSquare"/>IsMatrixSquare</term>
         <listitem>
          <synopsis>IsMatrixSquare (M)</synopsis>
          <para>Vérifie si une matrice est carrée, c'est-à-dire que sa largeur est égale à sa hauteur.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsUpperTriangular"/>IsUpperTriangular</term>
         <listitem>
          <synopsis>IsUpperTriangular (M)</synopsis>
          <para>Is a matrix upper triangular?  That is, a matrix is upper triangular if all the entries below the diagonal are zero.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsValueOnly"/>IsValueOnly</term>
         <listitem>
          <synopsis>IsValueOnly (M)</synopsis>
          <para>Vérifie si une matrice est une matrice de nombres seulement. Beaucoup de fonctions internes contrôlent cela. Les valeurs peuvent être n'importe quels nombres y compris des complexes.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsVector"/>IsVector</term>
         <listitem>
          <synopsis>IsVector (v)</synopsis>
          <para>Si l'argument est un vecteur horizontal ou vertical. Genius ne fait pas de distinction entre une matrice et un vecteur, un vecteur est juste une matrice 1 par <varname>n</varname> ou <varname>n</varname> par 1.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsZero"/>IsZero</term>
         <listitem>
          <synopsis>IsZero (x)</synopsis>
          <para>Vérifie si une matrice est composée uniquement de zéros. Fonctionne également avec les nombres et dans ce cas, c'est équivalent à <userinput>x==0</userinput>. Lorsque <varname>x</varname> est <constant>null</constant>, il est considéré comme une matrice 0 par 0, aucune erreur n'est générée et <constant>true</constant> (vrai) est renvoyé car la condition est vide.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LowerTriangular"/>LowerTriangular</term>
         <listitem>
          <synopsis>LowerTriangular (M)</synopsis>
          <para>Renvoie une copie de la matrice <varname>M</varname> avec tous les éléments au dessus de la diagonale mis à zéro.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MakeDiagonal"/>MakeDiagonal</term>
         <listitem>
          <synopsis>MakeDiagonal (v,param...)</synopsis>
          <para>Alias : <function>diag</function></para>
	  <para>Make diagonal matrix from a vector.  Alternatively you can pass
		  in the values to put on the diagonal as arguments.  So
		  <userinput>MakeDiagonal([1,2,3])</userinput> is the same as
		  <userinput>MakeDiagonal(1,2,3)</userinput>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Matrice_diagonale">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/DiagonalMatrix.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MakeVector"/>MakeVector</term>
         <listitem>
          <synopsis>MakeVector (A)</synopsis>
          <para>Construit un vecteur colonne à partir d'une matrice en mettant les colonnes les unes au dessus des autres. Renvoie <constant>null</constant> si <constant>null</constant> est fourni.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MatrixProduct"/>MatrixProduct</term>
         <listitem>
          <synopsis>MatrixProduct (A)</synopsis>
          <para>Calcule et renvoie le produit de tous les éléments d'une matrice ou d'un vecteur.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MatrixSum"/>MatrixSum</term>
         <listitem>
          <synopsis>MatrixSum (A)</synopsis>
          <para>Calcule et renvoie la somme de tous les éléments d'une matrice ou d'un vecteur.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MatrixSumSquares"/>MatrixSumSquares</term>
         <listitem>
          <synopsis>MatrixSumSquares (A)</synopsis>
          <para>Calcule la somme du carré de tous les éléments d'une matrice ou d'un vecteur.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NonzeroColumns"/>NonzeroColumns</term>
         <listitem>
          <synopsis>NonzeroColumns (M)</synopsis>
          <para>Returns a row vector of the indices of nonzero columns in the matrix <varname>M</varname>.</para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NonzeroElements"/>NonzeroElements</term>
         <listitem>
          <synopsis>NonzeroElements (v)</synopsis>
          <para>Returns a row vector of the indices of nonzero elements in the vector <varname>v</varname>.</para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-OuterProduct"/>OuterProduct</term>
         <listitem>
          <synopsis>OuterProduct (u,v)</synopsis>
          <para>Retourne le produit tensoriel de deux vecteurs, c'est-à-dire que si on suppose que <varname>u</varname> et <varname>v</varname> sont des vecteurs colonnes, alors le produit tensoriel est <userinput>v * u.'</userinput>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ReverseVector"/>ReverseVector</term>
         <listitem>
          <synopsis>ReverseVector (v)</synopsis>
	  <para>Inverse l'ordre des éléments d'un vecteur. Renvoie <constant>null</constant> si <constant>null</constant> est fourni</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RowSum"/>RowSum</term>
         <listitem>
          <synopsis>RowSum (m)</synopsis>
          <para>Calcule la somme pour chaque ligne d'une matrice et renvoie un vecteur colonne contenant le résultat.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RowSumSquares"/>RowSumSquares</term>
         <listitem>
          <synopsis>RowSumSquares (m)</synopsis>
          <para>Calculate sum of squares of each row in a matrix and return a vertical vector with the results.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RowsOf"/>RowsOf</term>
         <listitem>
          <synopsis>RowsOf (M)</synopsis>
	  <para>Gets the rows of a matrix as a vertical vector.  Each element
of the vector is a horizontal vector that is the corresponding row of
<varname>M</varname>.  This function is useful if you wish to loop over the
rows of a matrix.  For example, as <userinput>for r in RowsOf(M) do
something(r)</userinput>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SetMatrixSize"/>SetMatrixSize</term>
         <listitem>
          <synopsis>SetMatrixSize (M,lignes,colonnes)</synopsis>
          <para>Make new matrix of given size from old one.  That is, a new
	  matrix will be returned to which the old one is copied.  Entries that
	  don't fit are clipped and extra space is filled with zeros.
	  If <varname>rows</varname> or <varname>columns</varname> are zero
	  then <constant>null</constant> is returned.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ShuffleVector"/>ShuffleVector</term>
         <listitem>
          <synopsis>ShuffleVector (v)</synopsis>
	  <para>Shuffle elements in a vector.  Return <constant>null</constant> if given <constant>null</constant>.</para>
	  <para>Version 1.0.13 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SortVector"/>SortVector</term>
         <listitem>
          <synopsis>SortVector (v)</synopsis>
          <para>Trie les éléments d'un vecteur en ordre croissant.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-StripZeroColumns"/>StripZeroColumns</term>
         <listitem>
          <synopsis>StripZeroColumns (M)</synopsis>
          <para>Élimine toutes les colonnes entièrement nulles de <varname>M</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-StripZeroRows"/>StripZeroRows</term>
         <listitem>
          <synopsis>StripZeroRows (M)</synopsis>
          <para>Élimine toutes les lignes entièrement nulles de <varname>M</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Submatrix"/>Submatrix</term>
         <listitem>
          <synopsis>Submatrix (m,r,c)</synopsis>
          <para>Renvoie certaines colonnes et lignes d'une matrice. C'est équivalent à <userinput>m@(r,c)</userinput>. <varname>r</varname> et <varname>c</varname> doivent être des vecteurs de lignes et de colonnes (ou de simples nombres si vous avez besoin d'une seule ligne ou colonne).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SwapRows"/>SwapRows</term>
         <listitem>
          <synopsis>SwapRows (m,ligne1,ligne2)</synopsis>
          <para>Échange deux lignes dans une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-UpperTriangular"/>UpperTriangular</term>
         <listitem>
          <synopsis>UpperTriangular (M)</synopsis>
          <para>Renvoie une copie de la matrice <varname>M</varname> avec tous les éléments sous la diagonale mis à zéro.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-columns"/>columns</term>
         <listitem>
          <synopsis>columns (M)</synopsis>
          <para>Renvoie le nombre de colonnes d'une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-elements"/>elements</term>
         <listitem>
          <synopsis>elements (M)</synopsis>
          <para>Renvoie le nombre total d'éléments d'une matrice. C'est le nombre de colonnes multiplié par le nombre de lignes.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ones"/>ones</term>
         <listitem>
          <synopsis>ones (lignes,colonnes...)</synopsis>
	  <para>Crée une matrice de 1 (ou un vecteur colonne si un seul argument est donné). Renvoie <constant>null</constant> si ligne ou colonne est nul.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-rows"/>rows</term>
         <listitem>
          <synopsis>rows (M)</synopsis>
          <para>Renvoie le nombre de lignes d'une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-zeros"/>zeros</term>
         <listitem>
          <synopsis>zeros (lignes,colonnes...)</synopsis>
	  <para>Crée une matrice de 0 (ou un vecteur colonne si un seul argument est donné). Renvoie <constant>null</constant> si ligne ou colonne est nul.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-linear-algebra">
      <title>Algèbre linéaire</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-AuxiliaryUnitMatrix"/>AuxiliaryUnitMatrix</term>
         <listitem>
          <synopsis>AuxiliaryUnitMatrix (n)</synopsis>
          <para>Get the auxiliary unit matrix of size <varname>n</varname>.  This is a square matrix with that is all zero except the
superdiagonal being all ones.  It is the Jordan block matrix of one zero eigenvalue.</para>
          <para>
	    See
	    <ulink url="http://planetmath.org/encyclopedia/JordanCanonicalFormTheorem.html">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/JordanBlock.html">Mathworld</ulink> for more information on Jordan Canonical Form.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BilinearForm"/>BilinearForm</term>
         <listitem>
          <synopsis>BilinearForm (v,A,w)</synopsis>
          <para>Évalue (v,w) par rapport à la forme bilinéaire donnée par la matrice A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BilinearFormFunction"/>BilinearFormFunction</term>
         <listitem>
          <synopsis>BilinearFormFunction (A)</synopsis>
          <para>Renvoie une fonction qui évalue deux vecteurs par rapport à la forme bilinéaire donnée par A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CharacteristicPolynomial"/>CharacteristicPolynomial</term>
         <listitem>
          <synopsis>CharacteristicPolynomial (M)</synopsis>
          <para>Alias : <function>CharPoly</function></para>
	  <para>Renvoie le polynôme caractéristique d'un vecteur. C'est-à-dire renvoie les coefficients du polynôme en commençant par le terme constant. Ce polynôme est défini par <userinput>det(M-xI)</userinput>. Les racines de ce polynôme sont les valeurs propres de <varname>M</varname>. Consultez également <link linkend="gel-function-CharacteristicPolynomialFunction">CharacteristicPolynomialFunction</link>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/CharacteristicEquation.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CharacteristicPolynomialFunction"/>CharacteristicPolynomialFunction</term>
         <listitem>
          <synopsis>CharacteristicPolynomialFunction (M)</synopsis>
	  <para>Renvoie le polynôme caractéristique d'un vecteur sous la forme d'une fonction. Ce polynôme est défini par <userinput>det(M-xI)</userinput>. Les racines de ce polynôme sont les valeurs propres de <varname>M</varname>. Consultez également <link linkend="gel-function-CharacteristicPolynomial">CharacteristicPolynomial</link>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/CharacteristicEquation.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ColumnSpace"/>ColumnSpace</term>
         <listitem>
          <synopsis>ColumnSpace (M)</synopsis>
	  <para>Renvoie une matrice de base pour le sous-espace vectoriel d'une matrice. C'est-à-dire renvoie une matrice dont les colonnes forment une base pour le sous-espace vectoriel de <varname>M</varname>, donc l'espace engendré par les colonnes de <varname>M</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CommutationMatrix"/>CommutationMatrix</term>
         <listitem>
          <synopsis>CommutationMatrix (m, n)</synopsis>
	  <para>Return the commutation matrix <userinput>K(m,n)</userinput>, which is the unique <userinput>m*n</userinput> by
		  <userinput>m*n</userinput> matrix such that <userinput>K(m,n) * MakeVector(A) = MakeVector(A.')</userinput> for all <varname>m</varname> by <varname>n</varname>
		  matrices <varname>A</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CompanionMatrix"/>CompanionMatrix</term>
         <listitem>
          <synopsis>CompanionMatrix (p)</synopsis>
          <para>Matrice compagnon d'un polynôme (comme vecteur).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ConjugateTranspose"/>ConjugateTranspose</term>
         <listitem>
          <synopsis>ConjugateTranspose (M)</synopsis>
          <para>Transposée conjuguée d'une matrice (matrice adjointe). Identique à l'opérateur <userinput>'</userinput>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/ConjugateTranspose.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Convolution"/>Convolution</term>
         <listitem>
          <synopsis>Convolution (a,b)</synopsis>
          <para>Alias : <function>convol</function></para>
          <para>Calcule la convolution de deux vecteurs horizontaux.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ConvolutionVector"/>ConvolutionVector</term>
         <listitem>
          <synopsis>ConvolutionVector (a,b)</synopsis>
          <para>Calcule la convolution de deux vecteurs horizontaux. Renvoie le résultat sous la forme d'un vecteur dont les composants ne sont pas additionnées ensemble.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CrossProduct"/>CrossProduct</term>
         <listitem>
          <synopsis>CrossProduct (v,w)</synopsis>
	  <para>Produit vectoriel de deux vecteurs dans R<superscript>3</superscript> sous la forme d'un vecteur colonne.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DeterminantalDivisorsInteger"/>DeterminantalDivisorsInteger</term>
         <listitem>
          <synopsis>DeterminantalDivisorsInteger (M)</synopsis>
          <para>Renvoie les « determinantal divisors » d'une matrice d'entiers (et non pas son polynôme caractéristique).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DirectSum"/>DirectSum</term>
         <listitem>
          <synopsis>DirectSum (M,N...)</synopsis>
          <para>Somme directe de matrices.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DirectSumMatrixVector"/>DirectSumMatrixVector</term>
         <listitem>
          <synopsis>DirectSumMatrixVector (v)</synopsis>
          <para>Somme directe d'un vecteur de matrices.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Eigenvalues"/>Eigenvalues</term>
         <listitem>
          <synopsis>Eigenvalues (M)</synopsis>
          <para>Alias : <function>eig</function></para>
          <para>Renvoie les valeurs propres d'une matrice carrée. Ne fonctionne actuellement que pour les matrices de taille inférieure ou égale à 4 par 4 ou pour les matrices triangulaires (pour lesquelles les valeurs propres sont sur la diagonale).</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Valeur_propre,_vecteur_propre_et_espace_propre">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/Eigenvalue.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Eigenvalue.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Eigenvectors"/>Eigenvectors</term>
         <listitem>
          <synopsis>Eigenvectors (M)</synopsis>
          <synopsis>Eigenvectors (M, &amp;valeurspropres)</synopsis>
          <synopsis>Eigenvectors (M, &amp;valeurpropres, &amp;multiplicités)</synopsis>
	  <para>Renvoie les vecteurs propres d'une matrice carrée. Il est possible en option d'obtenir les valeurs propres ainsi que leur multiplicité algébrique. Ne fonctionne actuellement que pour les matrices 2x2.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Valeur_propre,_vecteur_propre_et_espace_propre">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/Eigenvector.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/Eigenvector.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-GramSchmidt"/>GramSchmidt</term>
         <listitem>
          <synopsis>GramSchmidt (v,B...)</synopsis>
	  <para>Applique le procédé de Gram-Schmidt (aux colonnes) par rapport au produit scalaire donné par <varname>B</varname>. Si <varname>B</varname> n'est pas fourni alors le produit hermitien standard est utilisé. <varname>B</varname> peut être soit une forme sesquilinéaire à deux arguments soit une matrice fournissant une forme sesquilinéaire. Les vecteurs seront orthogonaux par rapport à <varname>B</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/GramSchmidtOrthogonalization.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-HankelMatrix"/>HankelMatrix</term>
         <listitem>
          <synopsis>HankelMatrix (c,r)</synopsis>
          <para>Matrice de Hankel.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-HilbertMatrix"/>HilbertMatrix</term>
         <listitem>
          <synopsis>HilbertMatrix (n)</synopsis>
          <para>Matrice de Hilbert d'ordre <varname>n</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HilbertMatrix.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Image"/>Image</term>
         <listitem>
          <synopsis>Image (T)</synopsis>
          <para>Renvoie l'image (espace vectoriel engendré par les colonnes) d'une transformation linéaire.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-InfNorm"/>InfNorm</term>
         <listitem>
          <synopsis>InfNorm (v)</synopsis>
          <para>Renvoie la norme « infini », appelée aussi norme sup, ou encore norme de la convergence uniforme.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-InvariantFactorsInteger"/>InvariantFactorsInteger</term>
         <listitem>
          <synopsis>InvariantFactorsInteger (M)</synopsis>
          <para>Renvoie les facteurs invariants d'une matrice carrée (pas sa caractéristique).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-InverseHilbertMatrix"/>InverseHilbertMatrix</term>
         <listitem>
          <synopsis>InverseHilbertMatrix (n)</synopsis>
          <para>Matrice inverse de Hilbert d'ordre <varname>n</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HilbertMatrix.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsHermitian"/>IsHermitian</term>
         <listitem>
          <synopsis>IsHermitian (M)</synopsis>
          <para>Indique si une matrice est hermitienne. C'est-à-dire si elle est égale à sa transposée conjuguée.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/HermitianMatrix.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsInSubspace"/>IsInSubspace</term>
         <listitem>
          <synopsis>IsInSubspace (v,W)</synopsis>
          <para>Teste si un vecteur appartient à un sous-espace.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsInvertible"/>IsInvertible</term>
         <listitem>
          <synopsis>IsInvertible (n)</synopsis>
          <para>Is a matrix (or number) invertible (Integer matrix is invertible if and only if it is invertible over the integers).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsInvertibleField"/>IsInvertibleField</term>
         <listitem>
          <synopsis>IsInvertibleField (n)</synopsis>
          <para>Indique si une matrice (ou un nombre) est inversible sur un corps.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsNormal"/>IsNormal</term>
         <listitem>
          <synopsis>IsNormal (M)</synopsis>
          <para>Indique si <varname>M</varname> est une matrice normale, c'est-à-dire <userinput>M*M' == M'*M</userinput>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/NormalMatrix.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/NormalMatrix.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPositiveDefinite"/>IsPositiveDefinite</term>
         <listitem>
          <synopsis>IsPositiveDefinite (M)</synopsis>
          <para>Indique si <varname>M</varname> est une matrice hermitienne définie positive. C'est-à-dire si <userinput>HermitianProduct(M*v,v)</userinput> est toujours strictement positif pour tout vecteur <varname>v</varname>. <varname>M</varname> doit être carré et hermitienne pour être définie positive. Le contrôle effectué est que le déterminant de chaque sous-matrice principale n'est pas négatif (consultez <link linkend="gel-function-HermitianProduct">HermitianProduct</link>).</para>
	  <para>Notez que certains auteurs (par exemple Mathworld) n'exigent pas que <varname>M</varname> soit hermitienne, ainsi la condition porte sur la partie réelle du produit scalaire mais ce n'est pas le cas de Genius. Si vous souhaitez réaliser ce type de contrôle, vérifiez seulement la partie hermitienne de la matrice <varname>M</varname> comme ceci : <userinput>IsPositiveDefinite(M+M')</userinput>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/PositiveDefinite.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/PositiveDefiniteMatrix.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPositiveSemidefinite"/>IsPositiveSemidefinite</term>
         <listitem>
          <synopsis>IsPositiveSemidefinite (M)</synopsis>
          <para>Indique si <varname>M</varname> est une matrice hermitienne semi-définie positive. C'est-à-dire si <userinput>HermitianProduct(M*v,v)</userinput> est toujours non négatif pour tout vecteur <varname>v</varname>. <varname>M</varname> doit être carré et hermitienne pour être semi-définie positive. Le contrôle effectué est que le déterminant de chaque sous-matrice principale n'est pas négatif (consultez <link linkend="gel-function-HermitianProduct">HermitianProduct</link>).</para>
	  <para>Notez que certains auteurs n'exigent pas que <varname>M</varname> soit hermitienne, ainsi la condition porte sur la partie réelle du produit scalaire mais ce n'est pas le cas de Genius. Si vous souhaitez réaliser ce type de contrôle, vérifiez seulement la partie hermitienne de la matrice <varname>M</varname> comme ceci : <userinput>IsPositiveSemiDefinite(M+M')</userinput>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/PositiveSemidefinite.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/PositiveSemidefiniteMatrix.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsSkewHermitian"/>IsSkewHermitian</term>
         <listitem>
          <synopsis>IsSkewHermitian (M)</synopsis>
          <para>Indique si une matrice est anti-hermitienne. C'est-à-dire si sa transposée conjuguée est égale à l'opposée de la matrice.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/SkewHermitianMatrix.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsUnitary"/>IsUnitary</term>
         <listitem>
          <synopsis>IsUnitary (M)</synopsis>
          <para>Indique si une matrice est unitaire. C'est-à-dire si <userinput>M'*M</userinput> et <userinput>M*M'</userinput> sont égaux à l'identité.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/UnitaryTransformation.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/UnitaryMatrix.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-JordanBlock"/>JordanBlock</term>
         <listitem>
          <synopsis>JordanBlock (n,lambda)</synopsis>
          <para>Alias : <function>J</function></para>
          <para>Renvoie le bloc de Jordan correspondant à la valeur propre <varname>lambda</varname> de multiplicité <varname>n</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/JordanCanonicalFormTheorem.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/JordanBlock.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Kernel"/>Kernel</term>
         <listitem>
          <synopsis>Kernel (T)</synopsis>
          <para>Renvoie le noyau d'une transformation linéaire.</para>
	  <para>(consultez <link linkend="gel-function-NullSpace">NullSpace</link>)</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-KroneckerProduct"/>KroneckerProduct</term>
         <listitem>
          <synopsis>KroneckerProduct (M, N)</synopsis>
          <para>Aliases: <function>TensorProduct</function></para>
	  <para>
		  Compute the Kronecker product (tensor product in standard basis)
		  of two matrices.
	  </para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Kronecker_product">Wikipedia</ulink>, 
	    <ulink url="http://planetmath.org/encyclopedia/KroneckerProduct.html">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/KroneckerProduct.html">Mathworld</ulink> for more information.
          </para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term><anchor id="gel-function-LUDecomposition"/>LUDecomposition</term>
         <listitem>
          <synopsis>LUDecomposition (A, L, U)</synopsis>
          <para>
		  Get the LU decomposition of <varname>A</varname>, that is
		  find a lower triangular matrix and upper triangular
		  matrix whose product is <varname>A</varname>
	    Store the result in the <varname>L</varname> and
	    <varname>U</varname>, which should be references.  It returns <constant>true</constant>
	    if successful.
	    For example suppose that A is a square matrix, then after running:
	    <screen><prompt>genius&gt;</prompt> <userinput>LUDecomposition(A,&amp;L,&amp;U)</userinput>
</screen>
	    You will have the lower matrix stored in a variable called
	    <varname>L</varname> and the upper matrix in a variable called
	    <varname>U</varname>.
	  </para>
	  <para>
	    This is the LU decomposition of a matrix aka Crout and/or Cholesky
	    reduction.
	    (ISBN 0-201-11577-8 pp.99-103)
	    The upper triangular matrix features a diagonal
	    of values 1 (one).  This is not Doolittle's Method, which features
	    the 1's diagonal on the lower matrix. 
	  </para>
	  <para>Toutes les matrices ne possèdent pas de décomposition LU, par exemple <userinput>[0,1;1,0]</userinput> n'en a pas. Dans ce cas, cette fonction renvoie <constant>false</constant> (faux) et initialise <varname>L</varname> et <varname>U</varname> à <constant>null</constant>.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/LU_decomposition">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/encyclopedia/LUDecomposition.html">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/LUDecomposition.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Minor"/>Minor</term>
         <listitem>
          <synopsis>Minor (M,i,j)</synopsis>
          <para>Renvoie le mineur <varname>i</varname>-<varname>j</varname> d'une matrice.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/Minor.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NonPivotColumns"/>NonPivotColumns</term>
         <listitem>
          <synopsis>NonPivotColumns (M)</synopsis>
          <para>Renvoie les colonnes qui ne sont pas les colonnes pivot d'une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Norm"/>Norm</term>
         <listitem>
          <synopsis>Norm (v,p...)</synopsis>
          <para>Alias : <function>norm</function></para>
          <para>Renvoie la norme-p d'un vecteur (ou norme-2 si p n'est pas fourni).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NullSpace"/>NullSpace</term>
         <listitem>
          <synopsis>NullSpace (T)</synopsis>
          <para>Renvoie le noyau d'une matrice. C'est-à-dire le noyau de l'application linéaire que la matrice représente sous la forme d'une matrice dont l'espace des colonnes est le noyau de <varname>T</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/Nullspace.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Nullity"/>Nullity</term>
         <listitem>
          <synopsis>Nullity (M)</synopsis>
          <para>Alias : <function>nullity</function></para>
          <para>Renvoie la dimension du noyau de la matrice <varname>M</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/Nullity.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-OrthogonalComplement"/>OrthogonalComplement</term>
         <listitem>
          <synopsis>OrthogonalComplement (M)</synopsis>
          <para>Renvoie le complément orthogonal de l'espace des colonnes.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PivotColumns"/>PivotColumns</term>
         <listitem>
          <synopsis>PivotColumns (M)</synopsis>
          <para>Return pivot columns of a matrix, that is columns that have a leading 1 in row reduced form.  Also returns the row where they occur.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Projection"/>Projection</term>
         <listitem>
          <synopsis>Projection (v,W,B...)</synopsis>
	  <para>Projection du vecteur <varname>v</varname> sur le sous-espace <varname>W</varname> par rapport au produit scalaire donné par <varname>B</varname>. Si <varname>B</varname> n'est pas fourni alors le produit hermitien standard est utilisé. <varname>B</varname> peut être soit une forme sesquilinéaire à deux arguments soit une matrice fournissant une forme sesquilinéaire.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-QRDecomposition"/>QRDecomposition</term>
         <listitem>
          <synopsis>QRDecomposition (A, Q)</synopsis>
          <para>Calcule la décomposition QR d'une matrice carrée <varname>A</varname>, renvoie la matrice triangulaire supérieure <varname>R</varname> et définit <varname>Q</varname> comme la matrice orthogonale (unitaire). <varname>Q</varname> doit être une référence. Si vous ne voulez pas qu'elle soit renvoyée, utilisez <constant>null</constant>. Par exemple : <screen><prompt>genius&gt;</prompt> <userinput>R = QRDecomposition(A,&amp;Q)</userinput>
</screen> Vous obtenez la matrice supérieure dans une variable appelée <varname>R</varname> et la matrice orthogonale (unitaire) dans <varname>Q</varname>.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/QR_decomposition">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/encyclopedia/QRDecomposition.html">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/QRDecomposition.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RayleighQuotient"/>RayleighQuotient</term>
         <listitem>
          <synopsis>RayleighQuotient (A,x)</synopsis>
          <para>Renvoie le quotient de Rayleigh (aussi appelé le quotient ou rapport de Rayleigh-Ritz) d'une matrice et d'un vecteur.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/RayleighQuotient.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RayleighQuotientIteration"/>RayleighQuotientIteration</term>
         <listitem>
          <synopsis>RayleighQuotientIteration (A,x,epsilon,maxiter,vecref)</synopsis>
          <para>Cherche les valeurs propres de <varname>A</varname> en utilisant la méthode itérative du quotient de Rayleigh. <varname>x</varname> est une valeur initiale estimée pour un vecteur propre et peut être tirée au hasard. Si vous voulez avoir une chance de trouver des valeurs propres complexes, la partie imaginaire ne doit pas être nulle. Le programme effectue au maximum <varname>maxiter</varname> itérations et renvoie <constant>null</constant> s'il ne peut trouver une solution avec une précision inférieure à <varname>epsilon</varname>. <varname>vecref</varname> doit être soit <constant>null</constant> ou une référence à une variable dans laquelle le vecteur propre est enregistré.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/RayleighQuotient.html">Planetmath</ulink> pour plus d'informations sur le quotient de Rayleigh.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Rank"/>Rank</term>
         <listitem>
          <synopsis>Rank (M)</synopsis>
          <para>Alias : <function>rank</function></para>
          <para>Renvoie le rang d'une matrice.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/SylvestersLaw.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RosserMatrix"/>RosserMatrix</term>
         <listitem>
          <synopsis>RosserMatrix ()</synopsis>
          <para>Returns the Rosser matrix, which is a classic symmetric eigenvalue test problem.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Rotation2D"/>Rotation2D</term>
         <listitem>
          <synopsis>Rotation2D (angle)</synopsis>
          <para>Alias : <function>RotationMatrix</function></para>
          <para>Renvoie la matrice correspondant à la rotation centrée sur l'origine dans R<superscript>2</superscript>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Rotation3DX"/>Rotation3DX</term>
         <listitem>
          <synopsis>Rotation3DX (angle)</synopsis>
          <para>Renvoie la matrice correspondant à la rotation centrée sur l'origine dans R<superscript>3</superscript> autour de l'axe des x.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Rotation3DY"/>Rotation3DY</term>
         <listitem>
          <synopsis>Rotation3DY (angle)</synopsis>
          <para>Renvoie la matrice correspondant à la rotation centrée sur l'origine dans R<superscript>3</superscript> autour de l'axe des y.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Rotation3DZ"/>Rotation3DZ</term>
         <listitem>
          <synopsis>Rotation3DZ (angle)</synopsis>
          <para>Renvoie la matrice correspondant à la rotation centrée sur l'origine dans R<superscript>3</superscript> autour de l'axe des z.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RowSpace"/>RowSpace</term>
         <listitem>
          <synopsis>RowSpace (M)</synopsis>
          <para>Renvoie une matrice de base pour l'espace vectoriel engendré par les lignes d'une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SesquilinearForm"/>SesquilinearForm</term>
         <listitem>
          <synopsis>SesquilinearForm (v,A,w)</synopsis>
          <para>Évalue (v, w) par rapport à la forme sesquilinéaire donnée par la matrice A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SesquilinearFormFunction"/>SesquilinearFormFunction</term>
         <listitem>
          <synopsis>SesquilinearFormFunction (A)</synopsis>
          <para>Renvoie une fonction qui évalue deux vecteurs par rapport à la forme sesquilinéaire donnée par A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SmithNormalFormField"/>SmithNormalFormField</term>
         <listitem>
          <synopsis>SmithNormalFormField (A)</synopsis>
          <para>Returns the Smith normal form of a matrix over fields (will end up with 1's on the diagonal).</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Smith_normal_form">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SmithNormalFormInteger"/>SmithNormalFormInteger</term>
         <listitem>
          <synopsis>SmithNormalFormInteger (M)</synopsis>
          <para>Return the Smith normal form for square integer matrices over integers (not its characteristic).</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Smith_normal_form">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SolveLinearSystem"/>SolveLinearSystem</term>
         <listitem>
          <synopsis>SolveLinearSystem (M,V,params...)</synopsis>
	  <para>Résout le système linéaire Mx=V, renvoie V s'il y a une solution unique ou <constant>null</constant> sinon. Deux références d'arguments supplémentaires peuvent être utilisés pour recevoir les réductions de M et V.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ToeplitzMatrix"/>ToeplitzMatrix</term>
         <listitem>
          <synopsis>ToeplitzMatrix (c, r...)</synopsis>
	  <para>Renvoie la matrice de Toeplitz construite à partir de la première colonne c et (éventuellement) de la première ligne r. Si seule la colonne c est fournie alors elle est conjuguée et la version non conjuguée est utilisée pour la première ligne pour fournir une matrice hermitienne (si le premier élément est réel bien sûr).</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Toeplitz_matrix">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/encyclopedia/ToeplitzMatrix.html">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Trace"/>Trace</term>
         <listitem>
          <synopsis>Trace (M)</synopsis>
          <para>Alias : <function>trace</function></para>
          <para>Calcule la trace d'une matrice, c'est-à-dire la somme des éléments diagonaux.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Trace_(linear_algebra)">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/encyclopedia/Trace.html">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Transpose"/>Transpose</term>
         <listitem>
          <synopsis>Transpose (M)</synopsis>
          <para>Matrice transposée. C'est identique à l'opérateur <userinput>.'</userinput></para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Transpose">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/encyclopedia/Transpose.html">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VandermondeMatrix"/>VandermondeMatrix</term>
         <listitem>
          <synopsis>VandermondeMatrix (v)</synopsis>
          <para>Alias : <function>vander</function></para>
          <para>Renvoie la matrice de Vandermonde.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Vandermonde_matrix">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorAngle"/>VectorAngle</term>
         <listitem>
          <synopsis>VectorAngle (v,w,B...)</synopsis>
          <para>L'angle entre deux vecteurs par rapport au produit scalaire donné par <varname>B</varname>. Si <varname>B</varname> n'est pas fourni alors le produit hermitien standard est utilisé. <varname>B</varname> peut être soit une forme sesquilinéaire à deux arguments soit une matrice fournissant une forme sesquilinéaire.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorSpaceDirectSum"/>VectorSpaceDirectSum</term>
         <listitem>
          <synopsis>VectorSpaceDirectSum (M,N)</synopsis>
          <para>Somme directe des espaces vectoriels M et N.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorSubspaceIntersection"/>VectorSubspaceIntersection</term>
         <listitem>
          <synopsis>VectorSubspaceIntersection (M,N)</synopsis>
          <para>Intersection des sous-espaces donnés par M et N.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorSubspaceSum"/>VectorSubspaceSum</term>
         <listitem>
          <synopsis>VectorSubspaceSum (M,N)</synopsis>
          <para>Somme des espaces vectoriels M et N, c'est-à-dire {w | w=m+n, m dans M, n dans N}.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-adj"/>adj</term>
         <listitem>
          <synopsis>adj (m)</synopsis>
          <para>Alias : <function>Adjugate</function></para>
          <para>Renvoie la matrice adjointe d'une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-cref"/>cref</term>
         <listitem>
          <synopsis>cref (M)</synopsis>
          <para>Alias : <function>CREF</function><function>ColumnReducedEchelonForm</function></para>
          <para>Calcule la forme échelonnée réduite en colonnes.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-det"/>det</term>
         <listitem>
          <synopsis>det (M)</synopsis>
          <para>Alias : <function>Determinant</function></para>
          <para>Renvoie le déterminant d'une matrice.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/D%C3%A9terminant_%28math%C3%A9matiques%29">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/Determinant2.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ref"/>ref</term>
         <listitem>
          <synopsis>ref (M)</synopsis>
          <para>Alias : <function>REF</function><function>RowEchelonForm</function></para>
	  <para>Renvoie la matrice échelonnée en lignes (row echelon) d'une matrice. C'est-à-dire effectue une élimination de Gauss de <varname>M</varname>. Les lignes de pivot sont divisées pour que tous les pivots soient égaux à 1.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Matrice_%C3%A9chelonn%C3%A9e">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/RowEchelonForm.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-rref"/>rref</term>
         <listitem>
          <synopsis>rref (M)</synopsis>
          <para>Alias : <function>RREF</function><function>ReducedRowEchelonForm</function></para>
          <para>Renvoie la matrice échelonnée réduite en lignes (reduced row echelon) d'une matrice. C'est-à-dire effectue une élimination de Gauss-Jordan de <varname>M</varname>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Matrice_%C3%A9chelonn%C3%A9e">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/ReducedRowEchelonForm.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-combinatorics">
      <title>Combinatoire</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-Catalan"/>Catalan</term>
         <listitem>
          <synopsis>Catalan (n)</synopsis>
          <para>Renvoie le <varname>n</varname>-ième nombre catalan.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/CatalanNumbers.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Combinations"/>Combinations</term>
         <listitem>
          <synopsis>Combinations (k,n)</synopsis>
          <para>Renvoie toutes les combinaisons de k nombres de 1 à n comme un vecteur de vecteurs (consultez aussi <link linkend="gel-function-NextCombination">NextCombination</link>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DoubleFactorial"/>DoubleFactorial</term>
         <listitem>
          <synopsis>DoubleFactorial (n)</synopsis>
          <para>Double factorielle : <userinput>n(n-2)(n-4)...</userinput></para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/DoubleFactorial.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Factorial"/>Factorial</term>
         <listitem>
          <synopsis>Factorial (n)</synopsis>
          <para>Factorielle : <userinput>n(n-1)(n-2)...</userinput></para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/Factorial.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FallingFactorial"/>FallingFactorial</term>
         <listitem>
          <synopsis>FallingFactorial (n,k)</synopsis>
          <para>Factorielle décroissante : <userinput>(n)_k·=·n(n-1)...(n-(k-1))</userinput></para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/FallingFactorial.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Fibonacci"/>Fibonacci</term>
         <listitem>
          <synopsis>Fibonacci (x)</synopsis>
          <para>Alias : <function>fib</function></para>
          <para>Calcule le <varname>n</varname>-ième nombre de Fibonacci. C'est-à-dire le nombre défini de manière récursive par <userinput>Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)</userinput> et <userinput>Fibonacci(1) = Fibonacci(2) = 1</userinput>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Suite_de_Fibonacci">Wikipedia</ulink> ou <ulink url="http://planetmath.org/encyclopedia/FibonacciSequence.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/FibonacciNumber.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FrobeniusNumber"/>FrobeniusNumber</term>
         <listitem>
          <synopsis>FrobeniusNumber (v,param...)</synopsis>
          <para>Calcule le nombre de Frobenius. C'est-à-dire calcule le plus petit nombre qui ne peut pas être obtenu comme une combinaison linéaire d'entiers non négatifs d'un vecteur donné d'entiers non négatifs. Le vecteur peut être fourni sous la forme de nombre séparés ou d'un seul vecteur. Tous les nombres fournis doivent avoir un PGCD de 1.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/FrobeniusNumber.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-GaloisMatrix"/>GaloisMatrix</term>
         <listitem>
          <synopsis>GaloisMatrix (règle_de_combinaison)</synopsis>
          <para>Matrice de Galois étant donnée la règle de combinaison linéaire (a_1*x_+...+a_n*x_n=x_(n+1)).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-GreedyAlgorithm"/>GreedyAlgorithm</term>
         <listitem>
          <synopsis>FrobeniusNumber (n,v)</synopsis>
          <para>Trouve le vecteur <varname>c</varname> d'entiers non négatifs tel que le produit scalaire par <varname>v</varname> est égal à n. Si ce n'est pas possible, renvoie <constant>null</constant>. <varname>v</varname> doit être fourni trié dans l'ordre croissant et doit être composé d'entier non négatif.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/GreedyAlgorithm.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-HarmonicNumber"/>HarmonicNumber</term>
         <listitem>
          <synopsis>HarmonicNumber (n,r)</synopsis>
          <para>Alias : <function>HarmonicH</function></para>
          <para>Nombre harmonique, le <varname>n</varname>-ième nombre harmonique d'ordre <varname>r</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Hofstadter"/>Hofstadter</term>
         <listitem>
          <synopsis>Hofstadter (n)</synopsis>
          <para>Fonction de Hofstadter q(n) définie par q(1)=1, q(2)=1, q(n)=q(n-q(n-1))+q(n-q(n-2)).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinearRecursiveSequence"/>LinearRecursiveSequence</term>
         <listitem>
          <synopsis>LinearRecursiveSequence (valeurs_ensemencement,règle_de_combinaison,n)</synopsis>
          <para>Calcule la relation de récurrence linéaire en utilisant l'algorithme de Galois.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Multinomial"/>Multinomial</term>
         <listitem>
          <synopsis>Multinomial (v,param...)</synopsis>
          <para>Calcule les coefficients multinomiaux. Prend un vecteur de <varname>k</varname> entiers non négatifs et calcule les coefficients multinomiaux. Cela correspond aux coefficients dans le polynôme homogène à <varname>k</varname> variables avec les puissances correspondantes.</para>
	  <para>La formule pour <userinput>Multinomial(a,b,c)</userinput> peut s'écrire sous la forme :<programlisting>(a+b+c)! / (a!b!c!)
</programlisting> En d'autres termes, si vous n'avez que deux éléments alors <userinput>Multinomial(a,b)</userinput> est la même chose que <userinput>Binomial(a+b,a)</userinput> ou <userinput>Binomial(a+b,b)</userinput>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/MultinomialTheorem.html">Planetmath</ulink>, <ulink url="http://mathworld.wolfram.com/MultinomialCoefficient.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/Formule_du_multin%C3%B4me">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NextCombination"/>NextCombination</term>
         <listitem>
          <synopsis>NextCombination (v,n)</synopsis>
	  <para>Calcule la combinaison qui apparaîtrait après v dans un appel à la fonction combinations, la première combinaison devrait être <userinput>[1:k]</userinput>. Cette fonction est utile si vous devez parcourir beaucoup de combinaisons et que vous ne voulez pas gaspiller de la mémoire pour les enregistrer.</para>
	  <para>Par exemple, avec la fonction Combinations, vous devriez normalement écrire une boucle du style : <screen><userinput>for n in Combinations (4,6) do (
  SomeFunction (n)
);</userinput>
</screen> Mais avec NextCombination, vous écrivez quelque chose comme cela : <screen><userinput>n:=[1:4];
do (
  SomeFunction (n)
) while not IsNull(n:=NextCombination(n,6));</userinput>
</screen> Consultez également <link linkend="gel-function-Combinations">Combinations</link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Pascal"/>Pascal</term>
         <listitem>
          <synopsis>Pascal (i)</synopsis>
          <para>Get the Pascal's triangle as a matrix.  This will return
	  an <varname>i</varname>+1 by <varname>i</varname>+1 lower diagonal
	  matrix that is the Pascal's triangle after <varname>i</varname>
	  iterations.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/PascalsTriangle.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Permutations"/>Permutations</term>
         <listitem>
          <synopsis>Permutations (k,n)</synopsis>
          <para>Renvoie toutes les permutations de <varname>k</varname> nombres de 1 à <varname>n</varname> comme un vecteur de vecteurs.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/Permutation.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/Permutation">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RisingFactorial"/>RisingFactorial</term>
         <listitem>
          <synopsis>RisingFactorial (n,k)</synopsis>
          <para>Alias : <function>Pochhammer</function></para>
          <para>Factorielle croissante (Pochhammer) : (n)_k = n(n+1)...(n+(k-1)).</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/RisingFactorial.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-StirlingNumberFirst"/>StirlingNumberFirst</term>
         <listitem>
          <synopsis>StirlingNumberFirst (n,m)</synopsis>
          <para>Alias : <function>StirlingS1</function></para>
          <para>Nombre de Stirling du premier type.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/StirlingNumbersOfTheFirstKind.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/StirlingNumberoftheFirstKind.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-StirlingNumberSecond"/>StirlingNumberSecond</term>
         <listitem>
          <synopsis>StirlingNumberSecond (n,m)</synopsis>
          <para>Alias : <function>StirlingS2</function></para>
          <para>Nombre de Stirling du second type.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/StirlingNumbersSecondKind.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/StirlingNumberoftheSecondKind.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Subfactorial"/>Subfactorial</term>
         <listitem>
          <synopsis>Subfactorial (n)</synopsis>
          <para>Sous-factorielle : n! multiplié par sum_{k=1}^n (-1)^k/k!.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Triangular"/>Triangular</term>
         <listitem>
          <synopsis>Triangular (nième)</synopsis>
          <para>Calcule le <varname>n</varname>-ième nombre triangulaire.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/TriangularNumbers.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-nCr"/>nCr</term>
         <listitem>
          <synopsis>nCr (n,r)</synopsis>
          <para>Alias : <function>Binomial</function></para>
          <para>Calcule le nombre de combinaisons, c'est-à-dire le coefficient binomial. <varname>n</varname> peut être n'importe quel nombre réel.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/Choose.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-nPr"/>nPr</term>
         <listitem>
          <synopsis>nPr (n,r)</synopsis>
          <para>Calcule le nombre de permutations de taille <varname>r</varname> de nombres compris entre 1 et <varname>n</varname>.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/Permutation.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/Permutation">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-calculus">
      <title>Analyse</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-CompositeSimpsonsRule"/>CompositeSimpsonsRule</term>
         <listitem>
          <synopsis>CompositeSimpsonsRule (f,a,b,n)</synopsis>
          <para>Intégration de f par la méthode de Simpson composée sur l'intervalle [a,b] avec n sous-intervalles avec une erreur de l'ordre max(f'''')*h^4*(b-a)/180, notez que n doit être pair.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/SimpsonsRule.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-CompositeSimpsonsRuleTolerance"/>CompositeSimpsonsRuleTolerance</term>
         <listitem>
          <synopsis>CompositeSimpsonsRuleTolerance (f,a,b,FourthDerivativeBound,Tolerance)</synopsis>
          <para>Intégration de f par la méthode de Simpson composée sur l'intervalle [a,b] avec un nombre d'étapes calculé à l'aide de la borne de la dérivée quatrième et la tolérance souhaitée.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/SimpsonsRule.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Derivative"/>Derivative</term>
         <listitem>
          <synopsis>Derivative (f,x0)</synopsis>
          <para>Tente de calculer la dérivée en essayant d'abord une approche symbolique puis numérique.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-EvenPeriodicExtension"/>EvenPeriodicExtension</term>
         <listitem>
          <synopsis>EvenPeriodicExtension (f,L)</synopsis>
	  <para>Return a function that is the even periodic extension of
<function>f</function> with half period <varname>L</varname>.  That
is a function defined on the interval <userinput>[0,L]</userinput>
extended to be even on <userinput>[-L,L]</userinput> and then
extended to be periodic with period <userinput>2*L</userinput>.</para>
	  <para>Consultez aussi <link linkend="gel-function-OddPeriodicExtension">OddPeriodicExtension</link> et <link linkend="gel-function-PeriodicExtension">PeriodicExtension</link>.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FourierSeriesFunction"/>FourierSeriesFunction</term>
         <listitem>
          <synopsis>FourierSeriesFunction (a,b,L)</synopsis>
	  <para>Return a function that is a Fourier series with the
coefficients given by the vectors <varname>a</varname> (sines) and
<varname>b</varname> (cosines).  Note that <userinput>a@(1)</userinput> is
the constant coefficient!  That is, <userinput>a@(n)</userinput> refers to
the term <userinput>cos(x*(n-1)*pi/L)</userinput>, while
<userinput>b@(n)</userinput> refers to the term
<userinput>sin(x*n*pi/L)</userinput>.  Either <varname>a</varname>
or <varname>b</varname> can be <constant>null</constant>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/S%C3%A9rie_de_Fourier">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/FourierSeries.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-InfiniteProduct"/>InfiniteProduct</term>
         <listitem>
          <synopsis>InfiniteProduct (fonc,début,inc)</synopsis>
          <para>Essaie de calculer un produit infini pour une fonction à un seul argument.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-InfiniteProduct2"/>InfiniteProduct2</term>
         <listitem>
          <synopsis>InfiniteProduct2 (fonc,param,début,inc)</synopsis>
          <para>Essaie de calculer un produit infini pour une fonction à double arguments avec func(arg,n).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-InfiniteSum"/>InfiniteSum</term>
         <listitem>
          <synopsis>InfiniteSum (fonc,début,inc)</synopsis>
          <para>Essaie de calculer une somme infinie pour une fonction à un seul argument.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-InfiniteSum2"/>InfiniteSum2</term>
         <listitem>
          <synopsis>InfiniteSum2 (fonc,param,début,inc)</synopsis>
          <para>Essaie de calculer une somme infinie pour une fonction à double arguments avec func(arg,n).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsContinuous"/>IsContinuous</term>
         <listitem>
          <synopsis>IsContinuous (f,x0)</synopsis>
          <para>Essaie de voir si une fonction à valeur réelle est continue en x0 en calculant la limite en ce point.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsDifferentiable"/>IsDifferentiable</term>
         <listitem>
          <synopsis>IsDifferentiable (f,x0)</synopsis>
          <para>Teste de différentiabilité en approchant les limites gauche et droite et en les comparant.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LeftLimit"/>LeftLimit</term>
         <listitem>
          <synopsis>LeftLimit (f,x0)</synopsis>
          <para>Calcule la limite gauche d'une fonction à valeurs réelles en x0.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Limit"/>Limit</term>
         <listitem>
          <synopsis>Limit (f,x0)</synopsis>
          <para>Calcule la limite d'une fonction à valeur réelle en x0. Essaie de calculer les deux limites à gauche et à droite.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MidpointRule"/>MidpointRule</term>
         <listitem>
          <synopsis>MidpointRule (f,a,b,n)</synopsis>
          <para>Intégration par la méthode des rectangles.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalDerivative"/>NumericalDerivative</term>
         <listitem>
          <synopsis>NumericalDerivative (f,x0)</synopsis>
          <para>Alias : <function>NDerivative</function></para>
          <para>Essaie de calculer la dérivée par méthode numérique.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalFourierSeriesCoefficients"/>NumericalFourierSeriesCoefficients</term>
         <listitem>
          <synopsis>NumericalFourierSeriesCoefficients (f,L,N)</synopsis>
	  <para>Return a vector of vectors <userinput>[a,b]</userinput>
where <varname>a</varname> are the cosine coefficients and
<varname>b</varname> are the sine coefficients of
the Fourier series of
<function>f</function> with half-period <varname>L</varname> (that is defined
on <userinput>[-L,L]</userinput> and extended periodically) with coefficients
up to <varname>N</varname>th harmonic computed numerically.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/S%C3%A9rie_de_Fourier">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/FourierSeries.html">Mathworld</ulink> pour plus d'informations.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalFourierSeriesFunction"/>NumericalFourierSeriesFunction</term>
         <listitem>
          <synopsis>NumericalFourierSeriesFunction (f,L,N)</synopsis>
	  <para>Return a function that is the Fourier series of
<function>f</function> with half-period <varname>L</varname> (that is defined
on <userinput>[-L,L]</userinput> and extended periodically) with coefficients
up to <varname>N</varname>th harmonic computed numerically.  This is the
trigonometric real series composed of sines and cosines.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/S%C3%A9rie_de_Fourier">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/FourierSeries.html">Mathworld</ulink> pour plus d'informations.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalFourierCosineSeriesCoefficients"/>NumericalFourierCosineSeriesCoefficients</term>
         <listitem>
          <synopsis>NumericalFourierCosineSeriesCoefficients (f,L,N)</synopsis>
	  <para>Return a vector of coefficients of 
the cosine Fourier series of
<function>f</function> with half-period <varname>L</varname>.  That is,
we take <function>f</function> defined on <userinput>[0,L]</userinput>
take the even periodic extension and compute the Fourier series, which
only has cosine terms.  The series is computed up to the 
<varname>N</varname>th harmonic.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.
Note that <userinput>a@(1)</userinput> is
the constant coefficient!  That is, <userinput>a@(n)</userinput> refers to
the term <userinput>cos(x*(n-1)*pi/L)</userinput>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/S%C3%A9rie_de_Fourier">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/FourierCosineSeries.html">Mathworld</ulink> pour plus d'informations.</para>
	  <para>Version 1.0.7 onwards.</para>
	  </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalFourierCosineSeriesFunction"/>NumericalFourierCosineSeriesFunction</term>
         <listitem>
          <synopsis>NumericalFourierCosineSeriesFunction (f,L,N)</synopsis>
	  <para>Return a function that is the cosine Fourier series of
<function>f</function> with half-period <varname>L</varname>.  That is,
we take <function>f</function> defined on <userinput>[0,L]</userinput>
take the even periodic extension and compute the Fourier series, which
only has cosine terms.  The series is computed up to the 
<varname>N</varname>th harmonic.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/S%C3%A9rie_de_Fourier">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/FourierCosineSeries.html">Mathworld</ulink> pour plus d'informations.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalFourierSineSeriesCoefficients"/>NumericalFourierSineSeriesCoefficients</term>
         <listitem>
          <synopsis>NumericalFourierSineSeriesCoefficients (f,L,N)</synopsis>
	  <para>Return a vector of coefficients of 
the sine Fourier series of
<function>f</function> with half-period <varname>L</varname>.  That is,
we take <function>f</function> defined on <userinput>[0,L]</userinput>
take the odd periodic extension and compute the Fourier series, which
only has sine terms.  The series is computed up to the 
<varname>N</varname>th harmonic.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/S%C3%A9rie_de_Fourier">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/FourierSineSeries.html">Mathworld</ulink> pour plus d'informations.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalFourierSineSeriesFunction"/>NumericalFourierSineSeriesFunction</term>
         <listitem>
          <synopsis>NumericalFourierSineSeriesFunction (f,L,N)</synopsis>
	  <para>Return a function that is the sine Fourier series of
<function>f</function> with half-period <varname>L</varname>.  That is,
we take <function>f</function> defined on <userinput>[0,L]</userinput>
take the odd periodic extension and compute the Fourier series, which
only has sine terms.  The series is computed up to the 
<varname>N</varname>th harmonic.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/S%C3%A9rie_de_Fourier">Wikipedia</ulink> ou <ulink url="http://mathworld.wolfram.com/FourierSineSeries.html">Mathworld</ulink> pour plus d'informations.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalIntegral"/>NumericalIntegral</term>
         <listitem>
          <synopsis>NumericalIntegral (f,a,b)</synopsis>
          <para>Intégration de f entre a et b, en suivant la règle définie par <varname>NumericalIntegralFunction</varname> et en utilisant les <varname>NumericalIntegralSteps</varname> pas.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalLeftDerivative"/>NumericalLeftDerivative</term>
         <listitem>
          <synopsis>NumericalLeftDerivative (f,x0)</synopsis>
          <para>Essaie de calculer la dérivée à gauche par méthode numérique.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalLimitAtInfinity"/>NumericalLimitAtInfinity</term>
         <listitem>
          <synopsis>NumericalLimitAtInfinity (_f,step_fun,tolerance,successive_for_success,N)</synopsis>
          <para>Essaie de calculer la limite de f (step_fun(i)) lorsque i va de 1 à N.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NumericalRightDerivative"/>NumericalRightDerivative</term>
         <listitem>
          <synopsis>NumericalRightDerivative (f,x0)</synopsis>
          <para>Essaie de calculer la dérivée à droite par méthode numérique.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-OddPeriodicExtension"/>OddPeriodicExtension</term>
         <listitem>
          <synopsis>OddPeriodicExtension (f,L)</synopsis>
	  <para>Return a function that is the odd periodic extension of
<function>f</function> with half period <varname>L</varname>.  That
is a function defined on the interval <userinput>[0,L]</userinput>
extended to be odd on <userinput>[-L,L]</userinput> and then
extended to be periodic with period <userinput>2*L</userinput>.</para>
	  <para>Consultez aussi <link linkend="gel-function-EvenPeriodicExtension">EvenPeriodicExtension</link> et <link linkend="gel-function-PeriodicExtension">PeriodicExtension</link>.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-OneSidedFivePointFormula"/>OneSidedFivePointFormula</term>
         <listitem>
          <synopsis>OneSidedFivePointFormula (f,x0,h)</synopsis>
          <para>Calcule la dérivée d'un côté en utilisant une formule à cinq points.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-OneSidedThreePointFormula"/>OneSidedThreePointFormula</term>
         <listitem>
          <synopsis>OneSidedThreePointFormula (f,x0,h)</synopsis>
          <para>Calcule la dérivée d'un côté en utilisant une formule à trois points.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PeriodicExtension"/>PeriodicExtension</term>
         <listitem>
          <synopsis>PeriodicExtension (f,a,b)</synopsis>
	  <para>Return a function that is the periodic extension of
<function>f</function> defined on the interval <userinput>[a,b]</userinput>
and has period <userinput>b-a</userinput>.</para>
	  <para>Consultez également <link linkend="gel-function-OddPeriodicExtension">OddPeriodicExtension</link> et <link linkend="gel-function-EvenPeriodicExtension">EvenPeriodicExtension</link>.</para>
	  <para>Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RightLimit"/>RightLimit</term>
         <listitem>
          <synopsis>RightLimit (f,x0)</synopsis>
          <para>Calcule la limite à droite d'une fonction à valeurs réelles en x0.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-TwoSidedFivePointFormula"/>TwoSidedFivePointFormula</term>
         <listitem>
          <synopsis>TwoSidedFivePointFormula (f,x0,h)</synopsis>
          <para>Calcule la dérivée des deux côtés en utilisant une formule à cinq points.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-TwoSidedThreePointFormula"/>TwoSidedThreePointFormula</term>
         <listitem>
          <synopsis>TwoSidedThreePointFormula (f,x0,h)</synopsis>
          <para>Calcule la dérivée des deux côtés en utilisant une formule à trois points.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-functions">
      <title>Fonctions</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-Argument"/>Argument</term>
         <listitem>
          <synopsis>Argument (z)</synopsis>
          <para>Alias : <function>Arg</function> <function>arg</function></para>
          <para>Renvoie l'argument (angle) d'un nombre complexe.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BesselJ0"/>BesselJ0</term>
         <listitem>
          <synopsis>BesselJ0 (x)</synopsis>
          <para>Bessel function of the first kind of order 0.  Only implemented for real numbers.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BesselJ1"/>BesselJ1</term>
         <listitem>
          <synopsis>BesselJ1 (x)</synopsis>
          <para>Bessel function of the first kind of order 1.  Only implemented for real numbers.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BesselJn"/>BesselJn</term>
         <listitem>
          <synopsis>BesselJn (n,x)</synopsis>
	  <para>Bessel function of the first kind of order <varname>n</varname>.  Only implemented for real numbers.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BesselY0"/>BesselY0</term>
         <listitem>
          <synopsis>BesselY0 (x)</synopsis>
          <para>Bessel function of the second kind of order 0.  Only implemented for real numbers.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BesselY1"/>BesselY1</term>
         <listitem>
          <synopsis>BesselY1 (x)</synopsis>
          <para>Bessel function of the second kind of order 1.  Only implemented for real numbers.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-BesselYn"/>BesselYn</term>
         <listitem>
          <synopsis>BesselYn (n,x)</synopsis>
	  <para>Bessel function of the second kind of order <varname>n</varname>.  Only implemented for real numbers.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DirichletKernel"/>DirichletKernel</term>
         <listitem>
          <synopsis>DirichletKernel (n,t)</synopsis>
          <para>Calcul le noyau de Dirichlet d'ordre n.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DiscreteDelta"/>DiscreteDelta</term>
         <listitem>
          <synopsis>DiscreteDelta (v)</synopsis>
          <para>Renvoie 1 si et seulement si tous les éléments sont nuls.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-ErrorFunction"/>ErrorFunction</term>
         <listitem>
          <synopsis>ErrorFunction (x)</synopsis>
          <para>Alias : <function>erf</function></para>
          <para>Fonction erreur, 2/sqrt(pi) * int_0^x e^(-t^2) dt.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/ErrorFunction.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FejerKernel"/>FejerKernel</term>
         <listitem>
          <synopsis>FejerKernel (n,t)</synopsis>
          <para>Noyau Fejer d'ordre <varname>n</varname> évalué en <varname>t</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/FejerKernel.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-GammaFunction"/>GammaFunction</term>
         <listitem>
          <synopsis>GammaFunction (x)</synopsis>
          <para>Alias : <function>Gamma</function></para>
          <para>La fonction Gamma. Seules les valeurs réelles sont actuellement implémentées.</para>
          <para>
	    See
	    <ulink url="http://planetmath.org/encyclopedia/GammaFunction.html">Planetmath</ulink> or
	    <ulink url="http://en.wikipedia.org/wiki/Gamma_function">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-KroneckerDelta"/>KroneckerDelta</term>
         <listitem>
          <synopsis>KroneckerDelta (v)</synopsis>
          <para>Renvoie 1 si et seulement si tous les éléments sont égaux.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LambertW"/>LambertW</term>
         <listitem>
          <synopsis>LambertW (x)</synopsis>
	  <para>
		  The principal branch of Lambert W function computed for only
		  real values greater than or equal to <userinput>-1/e</userinput>.
		  That is, <function>LambertW</function> is the inverse of
		  the expression <userinput>x*e^x</userinput>.  Even for
		  real <varname>x</varname> this expression is not one to one and
		  therefore has two branches over <userinput>[-1/e,0)</userinput>.
		  See <link linkend="gel-function-LambertWm1"><function>LambertWm1</function></link> for the other real branch.
	  </para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Lambert_W_function">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LambertWm1"/>LambertWm1</term>
         <listitem>
          <synopsis>LambertWm1 (x)</synopsis>
	  <para>
		  The minus-one branch of Lambert W function computed for only
		  real values greater than or equal to <userinput>-1/e</userinput>
		  and less than 0.
		  That is, <function>LambertWm1</function> is the second
		  branch of the inverse of <userinput>x*e^x</userinput>.
		  See <link linkend="gel-function-LambertW"><function>LambertW</function></link> for the principal branch.
	  </para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Lambert_W_function">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MinimizeFunction"/>MinimizeFunction</term>
         <listitem>
          <synopsis>MinimizeFunction (fonc,x,incr)</synopsis>
          <para>Cherche la première valeur pour laquelle f(x)=0.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MoebiusDiskMapping"/>MoebiusDiskMapping</term>
         <listitem>
          <synopsis>MoebiusDiskMapping (a,z)</synopsis>
          <para>Transformation de Möbius du disque vers lui-même en faisant correspondre a à 0.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/MobiusTransformation.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MoebiusMapping"/>MoebiusMapping</term>
         <listitem>
          <synopsis>MoebiusMapping (z,z2,z3,z4)</synopsis>
          <para>Transformation de Möbius utilisant le rapport croisé en prenant z2, z3, z4 à 1, 0 et l'infini respectivement.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/MobiusTransformation.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MoebiusMappingInftyToInfty"/>MoebiusMappingInftyToInfty</term>
         <listitem>
          <synopsis>MoebiusMappingInftyToInfty (z,z2,z3)</synopsis>
          <para>Transformation de Möbius utilisant le rapport croisé en prenant l'infini à l'infini et z2, z3 à 1 et 0 respectivement.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/MobiusTransformation.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MoebiusMappingInftyToOne"/>MoebiusMappingInftyToOne</term>
         <listitem>
          <synopsis>MoebiusMappingInftyToOne (z,z3,z4)</synopsis>
          <para>Transformation de Möbius utilisant le rapport croisé en prenant l'infini à 1 et z3, z4 à 0 et l'infini respectivement.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/MobiusTransformation.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MoebiusMappingInftyToZero"/>MoebiusMappingInftyToZero</term>
         <listitem>
          <synopsis>MoebiusMappingInftyToZero (z,z2,z4)</synopsis>
          <para>Transformation de Möbius utilisant le rapport croisé en prenant l'infini à 0 et z2, z4 à 1 et l'infini respectivement.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/MobiusTransformation.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PoissonKernel"/>PoissonKernel</term>
         <listitem>
          <synopsis>PoissonKernel (r,sigma)</synopsis>
          <para>Le noyau de Poisson sur D(0,1) (non normalisé à 1, donc son intégrale vaut 2 pi).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PoissonKernelRadius"/>PoissonKernelRadius</term>
         <listitem>
          <synopsis>PoissonKernelRadius (r,sigma)</synopsis>
          <para>Le noyau de Poisson sur D(0,R) (non normalisé à 1).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RiemannZeta"/>RiemannZeta</term>
         <listitem>
          <synopsis>RiemannZeta (x)</synopsis>
          <para>Alias : <function>zeta</function></para>
          <para>Fonction zeta de Riemann (seules les valeurs réelles sont actuellement implémentées).</para>
          <para>
	    See
	    <ulink url="http://planetmath.org/encyclopedia/RiemannZetaFunction.html">Planetmath</ulink> or
	    <ulink url="http://en.wikipedia.org/wiki/Riemann_zeta_function">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-UnitStep"/>UnitStep</term>
         <listitem>
          <synopsis>UnitStep (x)</synopsis>
          <para>La fonction échelon vaut 0 pour x&lt;0, 1 sinon. C'est l'intégrale de la fonction delta de Dirac. Elle est aussi appelée fonction d'Heaviside.</para>
          <para>Consultez <ulink url="http://fr.wikipedia.org/wiki/Fonction_de_Heaviside">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-cis"/>cis</term>
         <listitem>
          <synopsis>cis (x)</synopsis>
          <para>La fonction <function>cis</function> est la même que <userinput>cos(x)+1i*sin(x)</userinput>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-deg2rad"/>deg2rad</term>
         <listitem>
          <synopsis>deg2rad (x)</synopsis>
          <para>Convertit les degrés en radians.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-rad2deg"/>rad2deg</term>
         <listitem>
          <synopsis>rad2deg (x)</synopsis>
          <para>Convertit les radians en degrés.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-sinc"/>sinc</term>
         <listitem>
          <synopsis>sinc (x)</synopsis>
	  <para>Calculates the unnormalized sinc function, that is
		  <userinput>sin(x)/x</userinput>.
		  If you want the normalized function call <userinput>sinc(pi*x)</userinput>.</para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Sinc">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-equation-solving">
      <title>Résolution d'équations</title>
      <variablelist>

        <varlistentry>
         <term><anchor id="gel-function-CubicFormula"/>CubicFormula</term>
         <listitem>
          <synopsis>CubicFormula (p)</synopsis>
          <para>Calcule les racines d'un polynôme cubique (de degré 3) en utilisant la formule cubique. Le polynôme doit être fourni sous la forme d'un vecteur de coefficients. Par exemple <userinput>4*x^3 + 2*x + 1</userinput> correspond au vecteur <userinput>[1,2,0,4]</userinput>. Renvoie un vecteur colonne contenant les trois solutions. La première solution est toujours celle qui est réelle puisqu'un polynôme cubique possède toujours une solution réelle.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/CubicFormula.html">Planetmath</ulink>, <ulink url="http://mathworld.wolfram.com/CubicFormula.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/%C3%89quation_cubique">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-EulersMethod"/>EulersMethod</term>
         <listitem>
          <synopsis>EulersMethod (f,x0,y0,x1,n)</synopsis>
          <para>
	    Use classical Euler's method to numerically solve y'=f(x,y) for
	    initial <varname>x0</varname>, <varname>y0</varname> going to
	    <varname>x1</varname> with <varname>n</varname> increments,
	    returns <varname>y</varname> at <varname>x1</varname>.
	    Unless you explicitly want to use Euler's method, you should really
	    think about using
	    <link linkend="gel-function-RungeKutta">RungeKutta</link>
	    for solving ODE.
	  </para>
	  <para>Les systèmes peuvent être résolus en ayant uniquement <varname>y</varname> sous la forme d'un vecteur (colonne) partout. C'est-à-dire <varname>y0</varname> peut être un vecteur et dans ce cas <varname>f</varname> doit prendre un nombre <varname>x</varname> et un vecteur de la même taille comme deuxième argument et doit renvoyer un vecteur de la même taille.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/EulerForwardMethod.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/M%C3%A9thode_d%27Euler">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-EulersMethodFull"/>EulersMethodFull</term>
         <listitem>
          <synopsis>EulersMethodFull (f,x0,y0,x1,n)</synopsis>
          <para>
	    Use classical Euler's method to numerically solve y'=f(x,y) for
	    initial <varname>x0</varname>, <varname>y0</varname> going to
	    <varname>x1</varname> with <varname>n</varname> increments,
	    returns a 2 by <userinput>n+1</userinput> matrix with the
	    <varname>x</varname> and <varname>y</varname> values.
	    Unless you explicitly want to use Euler's method, you should really
	    think about using
	    <link linkend="gel-function-RungeKuttaFull">RungeKuttaFull</link>
	    for solving ODE.
	    Suitable
	    for plugging into 
	    <link linkend="gel-function-LinePlotDrawLine">LinePlotDrawLine</link> or
	    <link linkend="gel-function-LinePlotDrawPoints">LinePlotDrawPoints</link>.
	  </para>
	  <para>
	    Example:
          <screen><prompt>genius&gt;</prompt> <userinput>LinePlotClear();</userinput>
<prompt>genius&gt;</prompt> <userinput>line = EulersMethodFull(`(x,y)=y,0,1.0,3.0,50);</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");</userinput>
</screen>
	  </para>
	  <para>Les systèmes peuvent être résolus en ayant uniquement <varname>y</varname> sous la forme d'un vecteur (colonne) partout. C'est-à-dire <varname>y0</varname> peut être un vecteur et dans ce cas <varname>f</varname> doit prendre un nombre <varname>x</varname> et un vecteur de la même taille comme deuxième argument et doit renvoyer un vecteur de la même taille.</para>
	  <para>
		  The output for a system is still a n by 2 matrix with the second
		  entry being a vector.  If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with
		  <link linkend="gel-function-ExpandMatrix">ExpandMatrix</link>,
		  and pick out the right columns.  Example:
          <screen><prompt>genius&gt;</prompt> <userinput>LinePlotClear();</userinput>
<prompt>genius&gt;</prompt> <userinput>lines = EulersMethodFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,500);</userinput>
<prompt>genius&gt;</prompt> <userinput>lines = ExpandMatrix(lines);</userinput>
<prompt>genius&gt;</prompt> <userinput>firstline = lines@(,[1,2]);</userinput>
<prompt>genius&gt;</prompt> <userinput>secondline = lines@(,[1,3]);</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotWindow = [0,10,-2,2];</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(firstline,"color","blue","legend","First");</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");</userinput>
</screen>
	  </para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/EulerForwardMethod.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/M%C3%A9thode_d%27Euler">Wikipedia</ulink> pour plus d'informations.</para>
	  <para>Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FindRootBisection"/>FindRootBisection</term>
         <listitem>
          <synopsis>FindRootBisection (f,a,b,TOL,N)</synopsis>
          <para>Find root of a function using the bisection method.
		  <varname>a</varname> and <varname>b</varname> are the initial guess interval,
		  <userinput>f(a)</userinput> and <userinput>f(b)</userinput> should have opposite signs.
	    <varname>TOL</varname> is the desired tolerance and
<varname>N</varname> is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector <userinput>[success,value,iteration]</userinput>, where <varname>success</varname> is a boolean indicating success, <varname>value</varname> is the last value computed, and <varname>iteration</varname> is the number of iterations done.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FindRootFalsePosition"/>FindRootFalsePosition</term>
         <listitem>
          <synopsis>FindRootFalsePosition (f,a,b,TOL,N)</synopsis>
          <para>Find root of a function using the method of false position.
		  <varname>a</varname> and <varname>b</varname> are the initial guess interval,
		  <userinput>f(a)</userinput> and <userinput>f(b)</userinput> should have opposite signs.
	    <varname>TOL</varname> is the desired tolerance and
<varname>N</varname> is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector <userinput>[success,value,iteration]</userinput>, where <varname>success</varname> is a boolean indicating success, <varname>value</varname> is the last value computed, and <varname>iteration</varname> is the number of iterations done.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FindRootMullersMethod"/>FindRootMullersMethod</term>
         <listitem>
          <synopsis>FindRootMullersMethod (f,x0,x1,x2,TOL,N)</synopsis>
          <para>Cherche la racine d'une fonction en utilisant la méthode de Muller. <varname>TOL</varname> est la tolérance permise et <varname>N</varname> est la limite du nombre d'itérations réalisées, 0 signifiant pas de limite. La fonction renvoie un vecteur <userinput>[succes,valeur,itération]</userinput> dans lequel <varname>succes</varname> est un booléen indiquant la réussite, <varname>valeur</varname> est la dernière valeur calculée et <varname>itération</varname> est le nombre d'itérations réalisées.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-FindRootSecant"/>FindRootSecant</term>
         <listitem>
          <synopsis>FindRootSecant (f,a,b,TOL,N)</synopsis>
          <para>Find root of a function using the secant method.
		  <varname>a</varname> and <varname>b</varname> are the initial guess interval,
		  <userinput>f(a)</userinput> and <userinput>f(b)</userinput> should have opposite signs.
	    <varname>TOL</varname> is the desired tolerance and
<varname>N</varname> is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector <userinput>[success,value,iteration]</userinput>, where <varname>success</varname> is a boolean indicating success, <varname>value</varname> is the last value computed, and <varname>iteration</varname> is the number of iterations done.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-HalleysMethod"/>HalleysMethod</term>
         <listitem>
          <synopsis>HalleysMethod (f,df,ddf,guess,epsilon,maxn)</synopsis>
	  <para>Find zeros using Halleys's method.  <varname>f</varname> is
		  the function, <varname>df</varname> is the derivative of
		  <varname>f</varname>, and <varname>ddf</varname> is the second derivative of
		  <varname>f</varname>.  <varname>guess</varname> is the initial
		  guess.  The function returns after two successive values are
		  within <varname>epsilon</varname> of each other, or after <varname>maxn</varname> tries, in which case the function returns <constant>null</constant> indicating failure.
	  </para>
	  <para>
	  See also <link linkend="gel-function-NewtonsMethod"><function>NewtonsMethod</function></link> and <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>.
  	  </para>
	  <para>
	    Example to find the square root of 10:
          <screen><prompt>genius&gt;</prompt> <userinput>HalleysMethod(`(x)=x^2-10,`(x)=2*x,`(x)=2,3,10^-10,100)</userinput>
</screen>
	  </para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Halley%27s_method">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NewtonsMethod"/>NewtonsMethod</term>
         <listitem>
          <synopsis>NewtonsMethod (f,df,guess,epsilon,maxn)</synopsis>
	  <para>Find zeros using Newton's method.  <varname>f</varname> is
		  the function and <varname>df</varname> is the derivative of
		  <varname>f</varname>.  <varname>guess</varname> is the initial
		  guess.  The function returns after two successive values are
		  within <varname>epsilon</varname> of each other, or after <varname>maxn</varname> tries, in which case the function returns <constant>null</constant> indicating failure.
	  </para>
	  <para>
	  See also <link linkend="gel-function-NewtonsMethodPoly"><function>NewtonsMethodPoly</function></link> and <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>.
  	  </para>
	  <para>
	    Example to find the square root of 10:
          <screen><prompt>genius&gt;</prompt> <userinput>NewtonsMethod(`(x)=x^2-10,`(x)=2*x,3,10^-10,100)</userinput>
</screen>
	  </para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Newtons_method">Wikipedia</ulink> for more information.
	  </para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PolynomialRoots"/>PolynomialRoots</term>
         <listitem>
          <synopsis>PolynomialRoots (p)</synopsis>
          <para>Calcule les racines d'un polynôme (de degré 1 à 4) en utilisant une des formules adaptée à ce type de polynôme. Le polynôme doit être fourni sous la forme d'un vecteur de coefficients. Par exemple <userinput>4*x^3 + 2*x + 1</userinput> correspond au vecteur <userinput>[1,2,0,4]</userinput>. Renvoie un vecteur colonne contenant les solutions.</para>
	  <para>La fonction appelle <link linkend="gel-function-QuadraticFormula">QuadraticFormula</link>, <link linkend="gel-function-CubicFormula">CubicFormula</link> et <link linkend="gel-function-QuarticFormula">QuarticFormula</link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-QuadraticFormula"/>QuadraticFormula</term>
         <listitem>
          <synopsis>QuadraticFormula (p)</synopsis>
          <para>Calcule les racines d'un polynôme quadratique (de degré 2) en utilisant la formule quadratique. Le polynôme doit être fourni sous la forme d'un vecteur de coefficients. <userinput>3*x^2 + 2*x + 1</userinput> correspond au vecteur <userinput>[1,2,3]</userinput>. Renvoie un vecteur colonne contenant les deux solutions.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/QuadraticFormula.html">Planetmath</ulink> ou <ulink url="http://mathworld.wolfram.com/QuadraticFormula.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-QuarticFormula"/>QuarticFormula</term>
         <listitem>
          <synopsis>QuarticFormula (p)</synopsis>
          <para>Calcule les racines d'un polynôme quartique (de degré 4) en utilisant la formule quartique. Le polynôme doit être fourni sous la forme d'un vecteur de coefficients. <userinput>5*x^4 + 2*x + 1</userinput> correspond au vecteur <userinput>[1,2,0,0,5]</userinput>. Renvoie un vecteur colonne contenant les quatre solutions.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/QuarticFormula.html">Planetmath</ulink>, <ulink url="http://mathworld.wolfram.com/QuarticEquation.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/%C3%89quation_quartique">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RungeKutta"/>RungeKutta</term>
         <listitem>
          <synopsis>RungeKutta (f,x0,y0,x1,n)</synopsis>
          <para>Utilise la méthode classique non adaptative de Runge-Kutta du quatrième ordre pour résoudre numériquement y'=f(x,y) avec les valeurs initiales <varname>x0</varname>, <varname>y0</varname> allant vers <varname>x1</varname> avec <varname>n</varname> incréments, renvoie <varname>y</varname> en <varname>x1</varname>.</para>
	  <para>Les systèmes peuvent être résolus en ayant uniquement <varname>y</varname> sous la forme d'un vecteur (colonne) partout. C'est-à-dire <varname>y0</varname> peut être un vecteur et dans ce cas <varname>f</varname> doit prendre un nombre <varname>x</varname> et un vecteur de la même taille comme deuxième argument et doit renvoyer un vecteur de la même taille.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/Runge-KuttaMethod.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/M%C3%A9thodes_de_Runge-Kutta">Wikipedia</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RungeKuttaFull"/>RungeKuttaFull</term>
         <listitem>
          <synopsis>RungeKuttaFull (f,x0,y0,x1,n)</synopsis>
          <para>
	    Use classical non-adaptive fourth order Runge-Kutta method to
	    numerically solve
	    y'=f(x,y) for initial <varname>x0</varname>, <varname>y0</varname>
	    going to <varname>x1</varname> with <varname>n</varname>
	    increments,
	    returns a 2 by <userinput>n+1</userinput> matrix with the
	    <varname>x</varname> and <varname>y</varname> values.  Suitable
	    for plugging into 
	    <link linkend="gel-function-LinePlotDrawLine">LinePlotDrawLine</link> or
	    <link linkend="gel-function-LinePlotDrawPoints">LinePlotDrawPoints</link>.
	  </para>
	  <para>
	    Example:
          <screen><prompt>genius&gt;</prompt> <userinput>LinePlotClear();</userinput>
<prompt>genius&gt;</prompt> <userinput>line = RungeKuttaFull(`(x,y)=y,0,1.0,3.0,50);</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");</userinput>
</screen>
	  </para>
	  <para>Les systèmes peuvent être résolus en ayant uniquement <varname>y</varname> sous la forme d'un vecteur (colonne) partout. C'est-à-dire <varname>y0</varname> peut être un vecteur et dans ce cas <varname>f</varname> doit prendre un nombre <varname>x</varname> et un vecteur de la même taille comme deuxième argument et doit renvoyer un vecteur de la même taille.</para>
	  <para>
		  The output for a system is still a n by 2 matrix with the second
		  entry being a vector.  If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with
		  <link linkend="gel-function-ExpandMatrix">ExpandMatrix</link>,
		  and pick out the right columns.  Example:
          <screen><prompt>genius&gt;</prompt> <userinput>LinePlotClear();</userinput>
<prompt>genius&gt;</prompt> <userinput>lines = RungeKuttaFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,100);</userinput>
<prompt>genius&gt;</prompt> <userinput>lines = ExpandMatrix(lines);</userinput>
<prompt>genius&gt;</prompt> <userinput>firstline = lines@(,[1,2]);</userinput>
<prompt>genius&gt;</prompt> <userinput>secondline = lines@(,[1,3]);</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotWindow = [0,10,-2,2];</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(firstline,"color","blue","legend","First");</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");</userinput>
</screen>
	  </para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/Runge-KuttaMethod.html">Mathworld</ulink> ou <ulink url="http://fr.wikipedia.org/wiki/M%C3%A9thodes_de_Runge-Kutta">Wikipedia</ulink> pour plus d'informations.</para>
	  <para>Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>


      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-statistics">
      <title>Statistiques</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-Average"/>Average</term>
         <listitem>
          <synopsis>Average (m)</synopsis>
          <para>Alias : <function>average</function><function>Mean</function><function>mean</function></para>
          <para>Calcule la moyenne de toute une matrice.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/ArithmeticMean.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-GaussDistribution"/>GaussDistribution</term>
         <listitem>
          <synopsis>GaussDistribution (x,sigma)</synopsis>
	  <para>Intégrale de la fonction de Gauss de 0 à <varname>x</varname> (aire sous la courbe normale).</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/NormalDistribution.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-GaussFunction"/>GaussFunction</term>
         <listitem>
          <synopsis>GaussFunction (x,sigma)</synopsis>
          <para>Fonction distribution de Gauss normalisée (courbe normale).</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/NormalDistribution.html">Mathworld</ulink> pour plus d'informations.</para>

         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Median"/>Median</term>
         <listitem>
          <synopsis>Median (m)</synopsis>
          <para>Alias : <function>median</function></para>
          <para>Calcule la médiane de toute une matrice.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/StatisticalMedian.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PopulationStandardDeviation"/>PopulationStandardDeviation</term>
         <listitem>
          <synopsis>PopulationStandardDeviation (m)</synopsis>
          <para>Alias : <function>stdevp</function></para>
          <para>Calcule l'écart type de la population de toute une matrice.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RowAverage"/>RowAverage</term>
         <listitem>
          <synopsis>RowAverage (m)</synopsis>
          <para>Alias : <function>RowMean</function></para>
          <para>Calcule la moyenne de chaque ligne d'une matrice.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/ArithmeticMean.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RowMedian"/>RowMedian</term>
         <listitem>
          <synopsis>RowMedian (m)</synopsis>
          <para>Calcule la médiane de chaque ligne d'une matrice et renvoie un vecteur colonne.</para>
          <para>Consultez <ulink url="http://mathworld.wolfram.com/StatisticalMedian.html">Mathworld</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RowPopulationStandardDeviation"/>RowPopulationStandardDeviation</term>
         <listitem>
          <synopsis>RowPopulationStandardDeviation (m)</synopsis>
          <para>Alias : <function>rowstdevp</function></para>
          <para>Calcule l'écart type de la population des lignes d'une matrice et renvoie un vecteur colonne.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-RowStandardDeviation"/>RowStandardDeviation</term>
         <listitem>
          <synopsis>RowStandardDeviation (m)</synopsis>
          <para>Alias : <function>rowstdev</function></para>
          <para>Calcule l'écart type des lignes d'une matrice et renvoie un vecteur colonne.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
	 <term><anchor id="gel-function-StandardDeviation"/>StandardDeviation</term>
         <listitem>
          <synopsis>StandardDeviation (m)</synopsis>
          <para>Alias : <function>stdev</function></para>
          <para>Calcule l'écart type de toute une matrice.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-polynomials">
      <title>Polynômes</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-AddPoly"/>AddPoly</term>
         <listitem>
          <synopsis>AddPoly (p1,p2)</synopsis>
          <para>Ajoute deux polynômes (vecteurs).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-DividePoly"/>DividePoly</term>
         <listitem>
          <synopsis>DividePoly (p,q,&amp;r)</synopsis>
          <para>Divise deux polynômes (en tant que vecteurs) en utilisant la division longue. Renvoie le quotient des deux polynômes. L'argument optionnel <varname>r</varname> est utilisé pour renvoyer le reste. Le reste a un degré plus bas que <varname>q</varname>.</para>
          <para>Consultez <ulink url="http://planetmath.org/encyclopedia/PolynomialLongDivision.html">Planetmath</ulink> pour plus d'informations.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsPoly"/>IsPoly</term>
         <listitem>
          <synopsis>IsPoly (p)</synopsis>
          <para>Vérifie qu'un vecteur est utilisable en tant que polynôme.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MultiplyPoly"/>MultiplyPoly</term>
         <listitem>
          <synopsis>MultiplyPoly (p1,p2)</synopsis>
          <para>Multiplie deux polynômes (comme vecteurs).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-NewtonsMethodPoly"/>NewtonsMethodPoly</term>
         <listitem>
          <synopsis>NewtonsMethodPoly (poly,valeurinitiale,epsilon,maxn)</synopsis>
	  <para>Find a root of a polynomial using Newton's method.  <varname>poly</varname> is
		  the polynomial as a vector and <varname>guess</varname> is the initial
		  guess.  The function returns after two successive values are
		  within <varname>epsilon</varname> of each other, or after <varname>maxn</varname> tries, in which case the function returns <constant>null</constant> indicating failure.
	  </para>
	  <para>
	  See also <link linkend="gel-function-NewtonsMethod"><function>NewtonsMethod</function></link>.
  	  </para>
	  <para>
	    Example to find the square root of 10:
          <screen><prompt>genius&gt;</prompt> <userinput>NewtonsMethodPoly([-10,0,1],3,10^-10,100)</userinput>
</screen>
	  </para>
          <para>
	    See
	    <ulink url="http://en.wikipedia.org/wiki/Newtons_method">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Poly2ndDerivative"/>Poly2ndDerivative</term>
         <listitem>
          <synopsis>Poly2ndDerivative (p)</synopsis>
          <para>Renvoie la dérivée seconde du polynôme (comme vecteur).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PolyDerivative"/>PolyDerivative</term>
         <listitem>
          <synopsis>PolyDerivative (p)</synopsis>
          <para>Prend la dérivée du polynôme (comme vecteur).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PolyToFunction"/>PolyToFunction</term>
         <listitem>
          <synopsis>PolyToFunction (p)</synopsis>
          <para>Fabrique une fonction à partir d'un polynôme (comme vecteur).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PolyToString"/>PolyToString</term>
         <listitem>
          <synopsis>PolyToString (p,var...)</synopsis>
          <para>Fabrique une chaîne à partir d'un polynôme (comme vecteur).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SubtractPoly"/>SubtractPoly</term>
         <listitem>
          <synopsis>SubtractPoly (p1,p2)</synopsis>
          <para>Soustrait deux polynômes (comme vecteur).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-TrimPoly"/>TrimPoly</term>
         <listitem>
          <synopsis>TrimPoly (p)</synopsis>
          <para>Tronque les zéros d'un polynôme (défini comme vecteur).</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-set-theory">
      <title>Théorie des ensembles</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-Intersection"/>Intersection</term>
         <listitem>
          <synopsis>Intersection (X,Y)</synopsis>
          <para>Renvoie l'intersection, selon la théorie des ensembles, de X et Y (X et Y sont des vecteurs supposés être des ensembles).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsIn"/>IsIn</term>
         <listitem>
          <synopsis>IsIn (x,X)</synopsis>
	  <para>Renvoie <constant>true</constant> (vrai) si l'élément x fait partie de l'ensemble X (où X est un vecteur supposé être un ensemble).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-IsSubset"/>IsSubset</term>
         <listitem>
          <synopsis>IsSubset (X, Y)</synopsis>
	  <para>Renvoie <constant>true</constant> (vrai) si X est un sous-ensemble de Y (X et Y sont des vecteurs supposés être des ensembles).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MakeSet"/>MakeSet</term>
         <listitem>
          <synopsis>MakeSet (X)</synopsis>
          <para>Renvoie un vecteur où chaque élément de X n'apparaît qu'une seule fois.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SetMinus"/>SetMinus</term>
         <listitem>
          <synopsis>SetMinus (X,Y)</synopsis>
          <para>Renvoie la différence X-Y selon la théorie des ensembles (X et Y sont des vecteurs supposés être des ensembles).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-Union"/>Union</term>
         <listitem>
          <synopsis>Union (X,Y)</synopsis>
          <para>Renvoie l'union, selon la théorie des ensembles, de X et Y (X et Y sont des vecteurs supposés être des ensembles).</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-commutative-algebra">
      <title>Commutative Algebra</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-MacaulayBound"/>MacaulayBound</term>
         <listitem>
          <synopsis>MacaulayBound (c,d)</synopsis>
          <para>For a Hilbert function that is c for degree d, given the Macaulay bound for the Hilbert function of degree d+1 (The c^&lt;d&gt; operator from Green's proof).</para>
	  <para>Version 1.0.15 onwards.</para>
         </listitem>
        </varlistentry>
	
        <varlistentry>
         <term><anchor id="gel-function-MacaulayLowerOperator"/>MacaulayLowerOperator</term>
         <listitem>
          <synopsis>MacaulayLowerOperator (c,d)</synopsis>
          <para>The c_&lt;d&gt; operator from Green's proof of Macaulay's Theorem.</para>
	  <para>Version 1.0.15 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-MacaulayRep"/>MacaulayRep</term>
         <listitem>
          <synopsis>MacaulayRep (c,d)</synopsis>
          <para>Return the dth Macaulay representation of a positive integer c.</para>
	  <para>Version 1.0.15 onwards.</para>
         </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-miscellaneous">
      <title>Divers</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-ASCIIToString"/>ASCIIToString</term>
         <listitem>
          <synopsis>ASCIIToString (vec)</synopsis>
          <para>Convertit un vecteur de valeurs ASCII en chaîne.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-AlphabetToString"/>AlphabetToString</term>
         <listitem>
          <synopsis>AlphabetToString (vec,alphabet)</synopsis>
          <para>Convertit un vecteur d'indices en chaîne de caractères. Les indices correspondent à la position dans la chaîne <literal>alphabet</literal>, en commençant à zéro.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-StringToASCII"/>StringToASCII</term>
         <listitem>
          <synopsis>StringToASCII (chaîne)</synopsis>
          <para>Convertit une chaîne en vecteur de valeurs ASCII.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-StringToAlphabet"/>StringToAlphabet</term>
         <listitem>
          <synopsis>StringToAlphabet (chaîne,alphabet)</synopsis>
          <para>Convertit une <literal>chaîne</literal> de caractères en un vecteur d'indices correspondant à la position dans la chaîne <literal>alphabet</literal> (en commençant à zéro). Lorsque le caractère n'est pas dans l'<literal>alphabet</literal>, l'indice est -1.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-symbolic">
      <title>Calcul symbolique</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-SymbolicDerivative"/>SymbolicDerivative</term>
         <listitem>
          <synopsis>SymbolicDerivative (f)</synopsis>
          <para>Essaie de dériver symboliquement la fonction f, où f est une fonction à une variable.</para>
          <para>Exemples : <screen><prompt>genius&gt;</prompt> <userinput>SymbolicDerivative(sin)</userinput>
= (`(x)=cos(x))
<prompt>genius&gt;</prompt> <userinput>SymbolicDerivative(`(x)=7*x^2)</userinput>
= (`(x)=(7*(2*x)))
</screen></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SymbolicDerivativeTry"/>SymbolicDerivativeTry</term>
         <listitem>
          <synopsis>SymbolicDerivativeTry (f)</synopsis>
	  <para>Essaie de dériver symboliquement la fonction f, où f est une fonction à une variable, renvoie <constant>null</constant> en cas d'échec mais reste silencieux (consultez <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SymbolicNthDerivative"/>SymbolicNthDerivative</term>
         <listitem>
          <synopsis>SymbolicNthDerivative (f,n)</synopsis>
          <para>Essaie de dériver symboliquement une fonction n fois (consultez <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SymbolicNthDerivativeTry"/>SymbolicNthDerivativeTry</term>
         <listitem>
          <synopsis>SymbolicNthDerivativeTry (f,n)</synopsis>
	  <para>Essaie de dériver symboliquement une fonction n fois silencieusement et renvoie <constant>null</constant> en cas d'échec (consultez <link linkend="gel-function-SymbolicNthDerivative"><function>SymbolicNthDerivative</function></link>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SymbolicTaylorApproximationFunction"/>SymbolicTaylorApproximationFunction</term>
         <listitem>
          <synopsis>SymbolicTaylorApproximationFunction (f,x0,n)</synopsis>
	  <para>Attempt to construct the Taylor approximation function around x0 to the nth degree.
	  (See <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>)
          </para>
         </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-plotting">
      <title>Tracé de graphiques</title>
      <variablelist>
        <varlistentry>
         <term><anchor id="gel-function-ExportPlot"/>ExportPlot</term>
         <listitem>
          <synopsis>ExportPlot (file,type)</synopsis>
          <synopsis>ExportPlot (file)</synopsis>
          <para>
		  Export the contents of the plotting window to a file.
		  The type is a string that specifies the file type to
		  use, "png", "eps", or "ps".  If the type is not
		  specified, then it is taken to be the extension, in
		  which case the extension must be ".png", ".eps", or ".ps".
	  </para>
	  <para>
		  Note that files are overwritten without asking.
	  </para>
	  <para>
		  On successful export, true is returned.  Otherwise
		  error is printed and exception is raised.
	  </para>
          <para>
	    Examples:
          <screen><prompt>genius&gt;</prompt> <userinput>ExportPlot("file.png")</userinput>
<prompt>genius&gt;</prompt> <userinput>ExportPlot("/directory/file","eps")</userinput>
</screen>
          </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlot"/>LinePlot</term>
         <listitem>
          <synopsis>LinePlot (fonc1,fonc2,fonc3,...)</synopsis>
          <synopsis>LinePlot (func1,func2,func3,x1,x2)</synopsis>
          <synopsis>LinePlot (fonc1,fonc2,fonc3,x1,x2,y1,y2)</synopsis>
          <synopsis>LinePlot (func1,func2,func3,[x1,x2])</synopsis>
          <synopsis>LinePlot (func1,func2,func3,[x1,x2,y1,y2])</synopsis>
          <para>
	    Plot a function (or several functions) with a line.
	    First (up to 10) arguments are functions, then optionally
            you can specify the limits of the plotting window as
	    <varname>x1</varname>, <varname>x2</varname>,
	    <varname>y1</varname>, <varname>y2</varname>.  If limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>)
	    If the y limits are not specified, then the functions are computed and then the maxima and minima
	    are used.
          </para>
          <para>Le paramètre <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link> conditionne l'affichage de la légende.</para>
          <para>Exemples : <screen><prompt>genius&gt;</prompt> <userinput>LinePlot(sin,cos)</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlot(`(x)=x^2,-1,1,0,1)</userinput>
</screen></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotClear"/>LinePlotClear</term>
         <listitem>
          <synopsis>LinePlotClear ()</synopsis>
          <para>Affiche la fenêtre d'affichage du tracé et efface les courbes déjà tracées.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotDrawLine"/>LinePlotDrawLine</term>
         <listitem>
          <synopsis>LinePlotDrawLine (x1,y1,x2,y2,...)</synopsis>
          <synopsis>LinePlotDrawLine (v,...)</synopsis>
          <para>
	    Draw a line from <varname>x1</varname>,<varname>y1</varname> to
	    <varname>x2</varname>,<varname>y2</varname>.
	    <varname>x1</varname>,<varname>y1</varname>,
	    <varname>x2</varname>,<varname>y2</varname> can be replaced by an
	    <varname>n</varname> by 2 matrix for a longer polyline.
          </para>
          <para>
	    Extra parameters can be added to specify line color, thickness,
	    arrows, the plotting window, or legend.
	    You can do this by adding an argument string <userinput>"color"</userinput>, 
	    <userinput>"thickness"</userinput>,
	    <userinput>"window"</userinput>, 
	    <userinput>"arrow"</userinput>, or <userinput>"legend"</userinput>, and after it specify
	    the color, the thickness, the window
	    as 4-vector, type of arrow, or the legend.  (Arrow and window are from version 1.0.6 onwards.)
    	  </para>
    	  <para>
	    The color should be either a string indicating the common English word for the color
	    that GTK will recognize such as 
            <userinput>"red"</userinput>, <userinput>"blue"</userinput>, <userinput>"yellow"</userinput>, etc...
	    Alternatively the color can be specified in RGB format as
	    <userinput>"#rgb"</userinput>, <userinput>"#rrggbb"</userinput>, or
	    <userinput>"#rrrrggggbbbb"</userinput>, where the r, g, or b are hex digits of the red, green, and blue
	    components of the color.  Finally, since version 1.0.18, the color
	    can also be specified as a real vector specifying the red green and
	    blue components where the components are between 0 and 1, e.g. <userinput>[1.0,0.5,0.1]</userinput>.
    	  </para>
    	  <para>
	    The window should be given as usual as <userinput>[x1,x2,y1,y2]</userinput>, or
	    alternatively can be given as a string
	    <userinput>"fit"</userinput> in which case,
	    the x range will be set precisely and the y range will be set with
	    five percent borders around the line.
    	  </para>
    	  <para>
	    Arrow specification should be
	    <userinput>"origin"</userinput>,
	    <userinput>"end"</userinput>,
	    <userinput>"both"</userinput>, or
	    <userinput>"none"</userinput>.
    	  </para>
    	  <para>
	    Finally, legend should be a string that can be used as the legend in the
	    graph.  That is, if legends are being printed.
          </para>
	  <para>
	  Examples:
          <screen><prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(0,0,1,1,"color","blue","thickness",3)</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine([0,0;1,-1;-1,-1])</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine([0,0;1,1],"arrow","end")</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(RungeKuttaFull(`(x,y)=y,0,3,100),"color","blue","legend","The Solution")</userinput>
<prompt>genius&gt;</prompt> <userinput>for r=0.0 to 1.0 by 0.1 do LinePlotDrawLine([0,0;1,r],"color",[r,(1-r),0.5],"window",[0,1,0,1])</userinput>
</screen>
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotDrawPoints"/>LinePlotDrawPoints</term>
         <listitem>
          <synopsis>LinePlotDrawPoints (x,y,...)</synopsis>
          <synopsis>LinePlotDrawPoints (v,...)</synopsis>
          <para>
		  Draw a point at <varname>x</varname>,<varname>y</varname>.
		  The input can be an <varname>n</varname> by 2 matrix
		  for <varname>n</varname> different points.  This function has essentially the same
		  input as <link linkend="gel-function-LinePlotDrawLine">LinePlotDrawLine</link>.
          </para>
          <para>
	    Extra parameters can be added to specify line color, thickness,
	    the plotting window, or legend.
	    You can do this by adding an argument string <userinput>"color"</userinput>, 
	    <userinput>"thickness"</userinput>,
	    <userinput>"window"</userinput>, 
	    or <userinput>"legend"</userinput>, and after it specify
	    the color, the thickness, the window
	    as 4-vector, or the legend.
    	  </para>
    	  <para>
	    The color should be either a string indicating the common English word for the color
	    that GTK will recognize such as 
            <userinput>"red"</userinput>, <userinput>"blue"</userinput>, <userinput>"yellow"</userinput>, etc...
	    Alternatively the color can be specified in RGB format as
	    <userinput>"#rgb"</userinput>, <userinput>"#rrggbb"</userinput>, or
	    <userinput>"#rrrrggggbbbb"</userinput>, where the r, g, or b are hex digits of the red, green, and blue
	    components of the color.  Finally the color can also be specified as a real vector specifying the red green
	    and blue components where the components are between 0 and 1.
    	  </para>
    	  <para>
	    The window should be given as usual as <userinput>[x1,x2,y1,y2]</userinput>, or
	    alternatively can be given as a string
	    <userinput>"fit"</userinput> in which case,
	    the x range will be set precisely and the y range will be set with
	    five percent borders around the line.
    	  </para>
    	  <para>
	    Finally, legend should be a string that can be used as the legend in the
	    graph.  That is, if legends are being printed.
          </para>
	  <para>
	  Examples:
          <screen><prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(0,0,"color","blue","thickness",3)</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints([0,0;1,-1;-1,-1])</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(RungeKuttaFull(`(x,y)=y,0,3,100),"color","blue","legend","The Solution")</userinput>
</screen>
          </para>
	  <para>
		  Available from version 1.0.18 onwards.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotParametric"/>LinePlotParametric</term>
         <listitem>
          <synopsis>LinePlotParametric (xfonc,yfonc,...)</synopsis>
          <synopsis>LinePlotParametric (xfonc,yfonc,t1,t2,tinc)</synopsis>
          <synopsis>LinePlotParametric (xfonc,yfonc,t1,t2,tinc,x1,x2,y1,y2)</synopsis>
          <synopsis>LinePlotParametric (xfunc,yfunc,t1,t2,tinc,[x1,x2,y1,y2])</synopsis>
          <synopsis>LinePlotParametric (xfunc,yfunc,t1,t2,tinc,"fit")</synopsis>
          <para>Trace la courbe d'une fonction paramétrique. En premier viennent les fonctions de <varname>x</varname> et <varname>y</varname> puis, en option, les limites de <varname>t</varname> sous la forme <userinput>t1,t2,tinc</userinput> puis, en option, les limites de la fenêtre de tracé sous la forme <userinput>x1,x2,y1,y2</userinput>.</para>
	  <para>
	    If x and y limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>).
	    If instead the string "fit" is given for the x and y limits, then the limits are the maximum extent of
	    the graph
          </para>
          <para>Le paramètre <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link> conditionne l'affichage de la légende.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-LinePlotCParametric"/>LinePlotCParametric</term>
         <listitem>
          <synopsis>LinePlotCParametric (fonc,...)</synopsis>
          <synopsis>LinePlotCParametric (fonc,t1,t2,tinc)</synopsis>
          <synopsis>LinePlotCParametric (fonc,t1,t2,tinc,x1,x2,y1,y2)</synopsis>
          <para>Trace la courbe d'une fonction paramétrique à valeurs complexes. En premier vient la fonction qui renvoie <computeroutput>x+iy</computeroutput> puis, en option, les limites de <varname>t</varname> sous la forme <userinput>t1,t2,tinc</userinput> puis, en option, les limites de la fenêtre de tracé sous la forme <userinput>x1,x2,y1,y2</userinput>.</para>
	  <para>
	    If limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>).
	    If instead the string "fit" is given for the x and y limits, then the limits are the maximum extent of
	    the graph
          </para>
          <para>Le paramètre <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link> conditionne l'affichage de la légende.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PlotCanvasFreeze"/>PlotCanvasFreeze</term>
         <listitem>
          <synopsis>PlotCanvasFreeze ()</synopsis>
          <para>
		  Freeze drawing of the canvas plot temporarily.  Useful if you need to draw a bunch of elements
		  and want to delay drawing everything to avoid flicker in an animation.  After everything
		  has been drawn you should call <link linkend="gel-function-PlotCanvasThaw"><function>PlotCanvasThaw</function></link>.
          </para>
          <para>
		  The canvas is always thawed after end of any execution, so it will never remain frozen.  The moment
		  a new command line is shown for example the plot canvas is thawed automatically.  Also note that
		  calls to freeze and thaw may be safely nested.
          </para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PlotCanvasThaw"/>PlotCanvasThaw</term>
         <listitem>
          <synopsis>PlotCanvasThaw ()</synopsis>
          <para>
		  Thaw the plot canvas frozen by
		  <link linkend="gel-function-PlotCanvasFreeze"><function>PlotCanvasFreeze</function></link>
		  and redraw the canvas immediately.  The canvas is also always thawed after end of execution
		  of any program.
          </para>
	  <para>Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-PlotWindowPresent"/>PlotWindowPresent</term>
         <listitem>
          <synopsis>PlotWindowPresent ()</synopsis>
          <para>
		  Show and raise the plot window, creating it if necessary.
		  Normally the window is created when one of the plotting
		  functions is called, but it is not always raised if it
		  happens to be below other windows.  So this function is
		  good to call in scripts where the plot window might have 
		  been created before, and by now hidden behind the console
		  or other windows.
          </para>
	  <para>Version 1.0.19 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SlopefieldClearSolutions"/>SlopefieldClearSolutions</term>
         <listitem>
          <synopsis>SlopefieldClearSolutions ()</synopsis>
          <para>Efface les solutions tracées par la fonction <link linkend="gel-function-SlopefieldDrawSolution"><function>SlopefieldDrawSolution</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SlopefieldDrawSolution"/>SlopefieldDrawSolution</term>
         <listitem>
          <synopsis>SlopefieldDrawSolution (x, y, dx)</synopsis>
          <para>Lorsqu'un tracé de champ de directions est actif, dessine une solution avec les conditions initiales spécifiées. La méthode standard de Runge-Kutta est utilisée avec l'incrément <varname>dx</varname>. Les solutions restent affichées sur le graphe jusqu'à ce qu'un tracé différent soit affiché ou jusqu'à ce que vous appeliez la fonction <link linkend="gel-function-SlopefieldClearSolutions"><function>SlopefieldClearSolutions</function></link>. Vous pouvez aussi utiliser l'interface graphique pour tracer des solutions et indiquer des conditions initiales spécifiques avec la souris.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SlopefieldPlot"/>SlopefieldPlot</term>
         <listitem>
          <synopsis>SlopefieldPlot (fonc)</synopsis>
          <synopsis>SlopefieldPlot (fonc,x1,x2,y1,y2)</synopsis>
          <para>Trace un champ de directions. La fonction <varname>fonc</varname> doit accepter deux nombres réels <varname>x</varname> et <varname>y</varname> ou seulement un nombre complexe. En option, vous pouvez indiquer les limites de la fenêtre de tracé comme <varname>x1</varname>, <varname>x2</varname>, <varname>y1</varname>, <varname>y2</varname>. Si les limites ne sont pas indiquées alors les limites actuellement utilisées s'appliquent (consultez <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>).</para>
          <para>Le paramètre <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link> conditionne l'affichage de la légende.</para>
          <para>Exemples : <screen><prompt>genius&gt;</prompt> <userinput>Slopefield(`(x,y)=sin(x-y),-5,5,-5,5)</userinput>
</screen></para>
         </listitem>
        </varlistentry>

	<varlistentry>
	 <term><anchor id="gel-function-SurfacePlot"/>SurfacePlot</term>
         <listitem>
          <synopsis>SurfacePlot (fonc)</synopsis>
          <synopsis>SurfacePlot (fonc,x1,x2,y1,y2,z1,z2)</synopsis>
          <synopsis>SurfacePlot (func,x1,x2,y1,y2)</synopsis>
          <synopsis>SurfacePlot (func,[x1,x2,y1,y2,z1,z2])</synopsis>
          <synopsis>SurfacePlot (func,[x1,x2,y1,y2])</synopsis>
          <para>
	    Plot a surface function that takes either two arguments or a complex number.  First comes the function then optionally limits as <varname>x1</varname>, <varname>x2</varname>,
	    <varname>y1</varname>, <varname>y2</varname>,
	    <varname>z1</varname>, <varname>z2</varname>.  If limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-SurfacePlotWindow"><function>SurfacePlotWindow</function></link>).
	    Genius can only plot a single surface function at this time.
          </para>
          <para>
	    If the z limits are not specified then the maxima and minima of the function are used.
	  </para>
          <para>Exemples : <screen><prompt>genius&gt;</prompt> <userinput>SurfacePlot(|sin|,-1,1,-1,1,0,1.5)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlot(`(x,y)=x^2+y,-1,1,-1,1,-2,2)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlot(`(z)=|z|^2,-1,1,-1,1,0,2)</userinput>
</screen></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SurfacePlotClear"/>SurfacePlotClear</term>
         <listitem>
          <synopsis>SurfacePlotClear ()</synopsis>
          <para>
            Show the surface plot window and clear out functions and any other
            lines that were drawn.
          </para>
          <para>
	    Available in version 1.0.19 and onwards.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SurfacePlotData"/>SurfacePlotData</term>
         <listitem>
          <synopsis>SurfacePlotData (data)</synopsis>
          <synopsis>SurfacePlotData (data,label)</synopsis>
          <synopsis>SurfacePlotData (data,x1,x2,y1,y2,z1,z2)</synopsis>
          <synopsis>SurfacePlotData (data,label,x1,x2,y1,y2,z1,z2)</synopsis>
          <synopsis>SurfacePlotData (data,[x1,x2,y1,y2,z1,z2])</synopsis>
          <synopsis>SurfacePlotData (data,label,[x1,x2,y1,y2,z1,z2])</synopsis>
          <para>
		  Plot a surface from data.  The data is an n by 3 matrix whose
		  rows are the x, y and z coordinates.  The data can also be
		  simply a vector whose length is a multiple of 3 and so
		  contains the triples of x, y, z.  The data should contain at
		  least 3 points.
	  </para>
          <para>
		  Optionally we can give the label and also optionally the
		  limits.  If limits are not given, they are computed from
		  the data, <link linkend="gel-function-SurfacePlotWindow"><function>SurfacePlotWindow</function></link>
		  is not used, if you want to use it, pass it in explicitly.
		  If label is not given then empty label is used.
	  </para>
          <para>
	    Examples:
          <screen><prompt>genius&gt;</prompt> <userinput>SurfacePlotData([0,0,0;1,0,1;0,1,1;1,1,3])</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotData(data,"My data")</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotData(data,-1,1,-1,1,0,10)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotData(data,SurfacePlotWindow)</userinput>
</screen>
          </para>
	  <para>
		  Here's an example of how to plot in polar coordinates,
		  in particular how to plot the function
		  <userinput>-r^2 * theta</userinput>:
          <screen><prompt>genius&gt;</prompt> <userinput>d:=null; for r=0 to 1 by 0.1 do for theta=0 to 2*pi by pi/5 do d=[d;[r*cos(theta),r*sin(theta),-r^2*theta]];</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotData(d)</userinput>
</screen>
          </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SurfacePlotDataGrid"/>SurfacePlotDataGrid</term>
         <listitem>
          <synopsis>SurfacePlotDataGrid (data,[x1,x2,y1,y2])</synopsis>
          <synopsis>SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2])</synopsis>
          <synopsis>SurfacePlotDataGrid (data,[x1,x2,y1,y2],label)</synopsis>
          <synopsis>SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2],label)</synopsis>
          <para>
		  Plot a surface from regular rectangular data.
		  The data is given in a n by m matrix where the rows are the
		  x coordinate and the columns are the y coordinate.
		  The x coordinate is divided into equal n-1 subintervals
		  and y coordinate is divided into equal m-1 subintervals.
		  The limits <varname>x1</varname> and <varname>x2</varname>
		  give the interval on the x-axis that we use, and 
		  the limits <varname>y1</varname> and <varname>y2</varname>
		  give the interval on the y-axis that we use.
		  If the limits <varname>z1</varname> and <varname>z2</varname>
		  are not given they are computed from the data (to be
		  the extreme values from the data).
	  </para>
          <para>
		  Optionally we can give the label, if label is not given then
		  empty label is used.
	  </para>
          <para>
	    Examples:
          <screen><prompt>genius&gt;</prompt> <userinput>SurfacePlotDataGrid([1,2;3,4],[0,1,0,1])</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotDataGrid(data,[-1,1,-1,1],"My data")</userinput>
<prompt>genius&gt;</prompt> <userinput>d:=null; for i=1 to 20 do for j=1 to 10 d@(i,j) = (0.1*i-1)^2-(0.1*j)^2;</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotDataGrid(d,[-1,1,0,1],"half a saddle")</userinput>
</screen>
          </para>
	  <para>Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SurfacePlotDrawLine"/>SurfacePlotDrawLine</term>
         <listitem>
          <synopsis>SurfacePlotDrawLine (x1,y1,z1,x2,y2,z2,...)</synopsis>
          <synopsis>SurfacePlotDrawLine (v,...)</synopsis>
          <para>
	    Draw a line from <varname>x1</varname>,<varname>y1</varname>,<varname>z1</varname> to
	    <varname>x2</varname>,<varname>y2</varname>,<varname>z2</varname>.
	    <varname>x1</varname>,<varname>y1</varname>,<varname>z1</varname>,
	    <varname>x2</varname>,<varname>y2</varname>,<varname>z2</varname> can be replaced by an
	    <varname>n</varname> by 3 matrix for a longer polyline.
          </para>
          <para>
	    Extra parameters can be added to specify line color, thickness,
	    arrows, the plotting window, or legend.
	    You can do this by adding an argument string <userinput>"color"</userinput>, 
	    <userinput>"thickness"</userinput>,
	    <userinput>"window"</userinput>,
	    or <userinput>"legend"</userinput>, and after it specify
	    the color, the thickness, the window
	    as 6-vector, or the legend.
    	  </para>
    	  <para>
	    The color should be either a string indicating the common English word for the color
	    that GTK will recognize such as 
            <userinput>"red"</userinput>, <userinput>"blue"</userinput>, <userinput>"yellow"</userinput>, etc...
	    Alternatively the color can be specified in RGB format as
	    <userinput>"#rgb"</userinput>, <userinput>"#rrggbb"</userinput>, or
	    <userinput>"#rrrrggggbbbb"</userinput>, where the r, g, or b are hex digits of the red, green, and blue
	    components of the color.  Finally, since version 1.0.18, the color
	    can also be specified as a real vector specifying the red green and
	    blue components where the components are between 0 and 1, e.g. <userinput>[1.0,0.5,0.1]</userinput>.
    	  </para>
    	  <para>
	    The window should be given as usual as <userinput>[x1,x2,y1,y2,z1,z2]</userinput>, or
	    alternatively can be given as a string
	    <userinput>"fit"</userinput> in which case,
	    the x range will be set precisely and the y range will be set with
	    five percent borders around the line.
    	  </para>
    	  <para>
	    Finally, legend should be a string that can be used as the legend in the
	    graph.  That is, if legends are being printed.
          </para>
	  <para>
	  Examples:
          <screen><prompt>genius&gt;</prompt> <userinput>SurfacePlotDrawLine(0,0,0,1,1,1,"color","blue","thickness",3)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotDrawLine([0,0,0;1,-1,2;-1,-1,-3])</userinput>
</screen>
          </para>
	  <para>
		  Available from version 1.0.19 onwards.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-SurfacePlotDrawPoints"/>SurfacePlotDrawPoints</term>
         <listitem>
          <synopsis>SurfacePlotDrawPoints (x,y,z,...)</synopsis>
          <synopsis>SurfacePlotDrawPoints (v,...)</synopsis>
          <para>
		  Draw a point at <varname>x</varname>,<varname>y</varname>,<varname>z</varname>.
		  The input can be an <varname>n</varname> by 3 matrix
		  for <varname>n</varname> different points.  This function has essentially the same
		  input as <link linkend="gel-function-SurfacePlotDrawLine">SurfacePlotDrawLine</link>.
          </para>
          <para>
	    Extra parameters can be added to specify line color, thickness,
	    the plotting window, or legend.
	    You can do this by adding an argument string <userinput>"color"</userinput>, 
	    <userinput>"thickness"</userinput>,
	    <userinput>"window"</userinput>, 
	    or <userinput>"legend"</userinput>, and after it specify
	    the color, the thickness, the window
	    as 6-vector, or the legend.
    	  </para>
    	  <para>
	    The color should be either a string indicating the common English word for the color
	    that GTK will recognize such as 
            <userinput>"red"</userinput>, <userinput>"blue"</userinput>, <userinput>"yellow"</userinput>, etc...
	    Alternatively the color can be specified in RGB format as
	    <userinput>"#rgb"</userinput>, <userinput>"#rrggbb"</userinput>, or
	    <userinput>"#rrrrggggbbbb"</userinput>, where the r, g, or b are hex digits of the red, green, and blue
	    components of the color.  Finally the color can also be specified as a real vector specifying the red green
	    and blue components where the components are between 0 and 1.
    	  </para>
    	  <para>
	    The window should be given as usual as <userinput>[x1,x2,y1,y2,z1,z2]</userinput>, or
	    alternatively can be given as a string
	    <userinput>"fit"</userinput> in which case,
	    the x range will be set precisely and the y range will be set with
	    five percent borders around the line.
    	  </para>
    	  <para>
	    Finally, legend should be a string that can be used as the legend in the
	    graph.  That is, if legends are being printed.
          </para>
	  <para>
	  Examples:
          <screen><prompt>genius&gt;</prompt> <userinput>SurfacePlotDrawPoints(0,0,0,"color","blue","thickness",3)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotDrawPoints([0,0,0;1,-1,2;-1,-1,1])</userinput>
</screen>
          </para>
	  <para>
		  Available from version 1.0.19 onwards.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorfieldClearSolutions"/>VectorfieldClearSolutions</term>
         <listitem>
          <synopsis>VectorfieldClearSolutions ()</synopsis>
          <para>Efface les solutions dessinées par la fonction <link linkend="gel-function-VectorfieldDrawSolution"><function>VectorfieldDrawSolution</function></link>.</para>
	  <para>Version 1.0.6 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorfieldDrawSolution"/>VectorfieldDrawSolution</term>
         <listitem>
          <synopsis>VectorfieldDrawSolution (x, y, dt, tlong)</synopsis>
          <para>Lorsqu'un tracé de champ de vecteurs est actif, dessine une solution avec les conditions initiales spécifiées. La méthode standard de Runge-Kutta est utilisée avec l'incrément <varname>dt</varname> sur un intervalle de temps <varname>tlong</varname>. Les solutions restent affichées sur le graphe jusqu'à ce qu'un tracé différent soit affiché ou jusqu'à ce que vous appeliez la fonction <link linkend="gel-function-SlopefieldClearSolutions"><function>VectorfieldClearSolutions</function></link>. Vous pouvez aussi utiliser l'interface graphique pour tracer des solutions et indiquer des conditions initiales spécifiques avec la souris.</para>
	  <para>Version 1.0.6 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term><anchor id="gel-function-VectorfieldPlot"/>VectorfieldPlot</term>
         <listitem>
          <synopsis>VectorfieldPlot (foncx, foncy)</synopsis>
          <synopsis>VectorfieldPlot (foncx, foncy, x1, x2, y1, y2)</synopsis>
          <para>Trace un champ de vecteurs à deux dimensions. La fonction <varname>funcx</varname> doit être la dérivée dx/dt du champ de vecteurs et la fonction <varname>funcy</varname> la dérivée dy/dt du champ de vecteurs. Les fonctions doivent accepter deux nombres réels <varname>x</varname> et <varname>y</varname> ou seulement un nombre complexe. Lorsque le paramètre <link linkend="gel-function-VectorfieldNormalized"><function>VectorfieldNormalized</function></link> est <constant>true</constant> (vrai) alors l'amplitude des vecteurs est normalisée. Seule la direction et non pas l'amplitude est tracée.</para>
	  <para>Vous pouvez spécifier, en option, les limites de la fenêtre de tracé sous la forme <varname>x1</varname>, <varname>x2</varname>, <varname>y1</varname>, <varname>y2</varname>, <varname>z1</varname>, <varname>z2</varname>. Si les limites ne sont pas indiquées alors les limites actuellement utilisées s'appliquent (consultez <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>).</para>
          <para>Le paramètre <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link> conditionne l'affichage de la légende.</para>
          <para>Exemples : <screen><prompt>genius&gt;</prompt> <userinput>VectorfieldPlot(`(x,y)=x^2-y, `(x,y)=y^2-x, -1, 1, -1, 1)</userinput>
</screen></para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

  </chapter>

  <!-- ============= GEL examples ============================= -->
  <chapter id="genius-gel-example-programs">
    <title>Exemple de programmes en GEL</title>

    <para>Voici une fonction qui calcule des factorielles : <programlisting><![CDATA[function f(x) = if x <= 1 then 1 else (f(x-1)*x)
]]></programlisting></para>
    <para>Avec des indentations, cela devient : <programlisting><![CDATA[function f(x) = (
  if x <= 1 then
    1
  else
    (f(x-1)*x)
)
]]></programlisting></para>
    <para>C'est un portage direct de la fonction factorielle de la page de manuel de <application>bc</application>. La syntaxe semble similaire à celle de <application>bc</application> mais différente par le fait que dans GEL, la dernière expression est celle qui est renvoyée. En utilisant la fonction <literal>return</literal> à la place, cela donnerait : <programlisting><![CDATA[function f(x) = (
  if (x <= 1) then return (1);
  return (f(x-1) * x)
)
]]></programlisting></para>

    <para>La façon, de loin la plus facile, de définir une fonction factorielle serait d'utiliser la boucle de produit de la manière suivante. Ce n'est pas seulement la plus courte et la plus rapide mais aussi probablement la version la plus lisible. <programlisting>function f(x) = prod k=1 to x do k
</programlisting></para>

    <para>
Here is a larger example, this basically redefines the internal
<link linkend="gel-function-ref"><function>ref</function></link> function to calculate the row echelon form of a
matrix.  The function <function>ref</function> is built in and much faster,
but this example demonstrates some of the more complex features of GEL.
<programlisting><![CDATA[# Calculate the row-echelon form of a matrix
function MyOwnREF(m) = (
  if not IsMatrix(m) or not IsValueOnly(m) then
    (error("MyOwnREF: argument not a value only matrix");bailout);
  s := min(rows(m), columns(m));
  i := 1;
  d := 1;
  while d <= s and i <= columns(m) do (

    # This just makes the anchor element non-zero if at
    # all possible
    if m@(d,i) == 0 then (
      j := d+1;
      while j <= rows(m) do (
        if m@(j,i) == 0 then
          (j=j+1;continue);
        a := m@(j,);
        m@(j,) := m@(d,);
        m@(d,) := a;
        j := j+1;
        break
      )
    );
    if m@(d,i) == 0 then
      (i:=i+1;continue);
    
    # Here comes the actual zeroing of all but the anchor
    # element rows
    j := d+1;
    while j <= rows(m)) do (
      if m@(j,i) != 0 then (
        m@(j,) := m@(j,)-(m@(j,i)/m@(d,i))*m@(d,)
      );
      j := j+1
    );
    m@(d,) := m@(d,) * (1/m@(d,i));
    d := d+1;
    i := i+1
  );
  m
)
]]></programlisting>
    </para>

  </chapter>

  <!-- ============= Customization ============================ -->
  <chapter id="genius-prefs"> 
    <title>Paramètres</title> 

    <para>Pour configurer l'<application>Outil de maths Genius</application>, choisissez <menuchoice><guimenu>Paramètres</guimenu><guimenuitem>Préférences</guimenuitem></menuchoice>. Il y a plusieurs paramètres de base fournis par le calculateur en plus de ceux fournis par la bibliothèque standard. Ils contrôlent le comportement du calculateur.</para>

    <note>
      <title>Modifications des paramètres avec GEL</title>
      <para>Beaucoup de paramètres dans Genius ne sont simplement que des variables globales qui peuvent être évaluées et auxquelles on peut attribuer des valeurs de la même manière que pour des variables normales. Consultez <xref linkend="genius-gel-variables"/> à propos de l'évaluation et <xref linkend="genius-gel-function-parameters"/> pour une liste des réglages qui peuvent être modifiés de cette façon.</para>
      <para>Par exemple, vous pouvez paramétrer le nombre maximum de chiffres pour l'affichage d'un résultat à 12 en saisissant : <programlisting>MaxDigits = 12
</programlisting></para>
    </note>

    <sect1 id="genius-prefs-output"> 
      <title>Sortie</title> 
      <variablelist> 
	<varlistentry>
	  <term> 
	    <guilabel>Nombre maximum de chiffres à afficher</guilabel>
      </term> 
	  <listitem>
		  <para>The maximum digits in a result (<link linkend="gel-function-MaxDigits"><function>MaxDigits</function></link>)</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term> 
	    <guilabel>Résultats en nombres flottants</guilabel>
      </term> 
	  <listitem>
		  <para>If the results should be always printed as floats (<link linkend="gel-function-ResultsAsFloats"><function>ResultsAsFloats</function></link>)</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term> 
	    <guilabel>Nombres flottants en notation scientifique</guilabel>
      </term> 
	  <listitem>
		  <para>If floats should be in scientific notation (<link linkend="gel-function-ScientificNotation"><function>ScientificNotation</function></link>)</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term> 
	    <guilabel>Toujours afficher les expressions complètes</guilabel>
      </term> 
	  <listitem>
		  <para>Should we print out full expressions for non-numeric return values (longer than a line) (<link linkend="gel-function-FullExpressions"><function>FullExpressions</function></link>)</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
	    <guilabel>Utiliser les fractions mixtes</guilabel>
      </term> 
	  <listitem>
		  <para>If fractions should be printed as mixed fractions such as "1 1/3" rather than "4/3". (<link linkend="gel-function-MixedFractions"><function>MixedFractions</function></link>)</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
	    <guilabel>Afficher 0.0 lorsqu'un nombre flottant est inférieur à 10^-x (0=ne jamais arrondir)</guilabel>
      </term> 
	  <listitem>
	  <para>How to chop output.  But only when other numbers nearby are large.
	   See the documentation of the parameter
          <link linkend="gel-function-OutputChopExponent"><function>OutputChopExponent</function></link>. </para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
            <guilabel>Arrondir les nombres uniquement si un autre nombre est plus grand que 10^-x</guilabel>
      </term> 
	  <listitem>
		  <para>When to chop output.  This is set by the parameter <link linkend="gel-function-OutputChopWhenExponent"><function>OutputChopWhenExponent</function></link>.
	   See the documentation of the parameter
          <link linkend="gel-function-OutputChopExponent"><function>OutputChopExponent</function></link>. </para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
	    <guilabel>Se souvenir des paramètres de sortie d'une session à l'autre</guilabel>
      </term> 
	  <listitem>
        <para>Si les réglages concernant la sortie dans le cadre <guilabel>Options pour la sortie des nombres/expressions</guilabel> doivent être conservés pour la session suivante. Ne s'applique pas au cadre <guilabel>Options pour la sortie erreurs/information</guilabel>.</para>
	      <para>Si ce n'est pas coché, les réglages précédemment enregistrés ou ceux par défaut sont utilisés à chaque lancement de Genius. Notez que les paramètres sont enregistrés à la fin de la session donc si vous souhaitez modifier la valeur par défaut, cochez cette case, redémarrez Genius puis décochez-la à nouveau.</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
	    <guilabel>Afficher les erreurs dans une boîte de dialogue</guilabel>
      </term> 
	  <listitem>
        <para>If set the errors will be displayed in a separate dialog, if
	unset the errors will be printed on the console.</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
	    <guilabel>Afficher les messages d'informations dans une boîte de dialogue</guilabel>
      </term> 
	  <listitem>
	<para>If set the information messages will be displayed in a separate
	dialog, if unset the information messages will be printed on the
	console.</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
	    <guilabel>Nombre maximum d'erreurs à afficher</guilabel>
      </term> 
	  <listitem>
        <para>
	  The maximum number of errors to return on one evaluation
	  (<link linkend="gel-function-MaxErrors"><function>MaxErrors</function></link>).  If you set this to 0 then
	  all errors are always returned.  Usually if some loop causes
	  many errors, then it is unlikely that you will be able to make
	  sense out of more than a few of these, so seeing a long list
	  of errors is usually not helpful.
	  </para>
	  </listitem>
	</varlistentry>
      </variablelist> 

      <para>En plus de ces préférences, il existe d'autres préférences qui ne peuvent être modifiées qu'en les paramétrant dans l'espace de la console. Pour celles qui peuvent affecter la sortie, consultez <xref linkend="genius-gel-function-parameters"/>.</para>

      <variablelist> 
	<varlistentry>
	  <term> 
	    <function>IntegerOutputBase</function>
      </term> 
	  <listitem>
        <para>La base utilisée pour afficher les entiers.</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
	    <function>OutputStyle</function>
      </term> 
	  <listitem>
	<para>A string, can be <literal>"normal"</literal>,
<literal>"latex"</literal>, <literal>"mathml"</literal> or
<literal>"troff"</literal> and it will affect how matrices (and perhaps other
stuff) is printed, useful for pasting into documents.  Normal style is the
default human readable printing style of <application>Genius Mathematics Tool</application>.  The other styles are for
typsetting in LaTeX, MathML (XML), or in Troff.</para>
	  </listitem>
	</varlistentry>
      </variablelist> 
   </sect1> 

    <sect1 id="genius-prefs-precision"> 
      <title>Précision</title> 
      <variablelist> 
	<varlistentry>
	  <term> 
	    <guilabel>Précision des nombres en virgule flottante</guilabel>
      </term> 
	  <listitem>
        <para>
	  The floating point precision in bits
	  (<link linkend="gel-function-FloatPrecision"><function>FloatPrecision</function></link>).
	  Note that changing this only affects newly computed quantities.
	  Old values stored in variables are obviously still in the old
	  precision and if you want to have them more precise you will have
	  to recompute them.  Exceptions to this are the system constants
	  such as <link linkend="gel-function-pi"><function>pi</function></link> or
	  <link linkend="gel-function-e"><function>e</function></link>.
	  </para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term> 
	    <guilabel>Se souvenir de la précision choisie d'une session à l'autre</guilabel>
      </term> 
	  <listitem>
        <para>Si le réglage de la précision doit être conservé pour la prochaine session. Si ce n'est pas coché, le paramétrage précédemment enregistré ou celui par défaut est utilisé à chaque lancement de Genius. Notez que les paramètres sont enregistrés à la fin de la session donc si vous souhaitez modifier la valeur par défaut, cochez cette case, redémarrez genius puis décochez-la à nouveau.</para>
	  </listitem>
	</varlistentry>
      </variablelist> 
    </sect1> 

    <sect1 id="genius-prefs-terminal"> 
      <title>Terminal</title> 

      <para>Le terminal se réfère à la console dans la zone de travail.</para>

      <variablelist> 
	<varlistentry>
	  <term> 
	    <guilabel>Lignes d'historique</guilabel>
      </term> 
	  <listitem>
        <para>Nombre de lignes d'historique dans le terminal.</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term> 
	    <guilabel>Police</guilabel>
      </term> 
	  <listitem>
        <para>La police à utiliser dans le terminal.</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term> 
	    <guilabel>Noir sur blanc</guilabel>
      </term> 
	  <listitem>
        <para>Si vous utilisez du noir sur blanc dans le terminal.</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term> 
	    <guilabel>Curseur clignotant</guilabel>
      </term> 
	  <listitem>
        <para>Si le curseur dans le terminal doit clignoter lorsque le terminal possède le focus. Cela peut être parfois ennuyant et génère du trafic inutile si vous utilisez Genius à distance.</para>
	  </listitem>
	</varlistentry>
      </variablelist> 
    </sect1> 

    <sect1 id="genius-prefs-memory"> 
      <title>Mémoire</title> 
      <variablelist> 
	<varlistentry>
	  <term> 
	    <guilabel>Nombre maximum de nœuds à allouer</guilabel>
      </term> 
	  <listitem>
        <para>
	   Internally all data is put onto small nodes in memory.  This gives
	   a limit on the maximum number of nodes to allocate for
	   computations.  This limit avoids the problem of running out of memory
	   if you do something by mistake that uses too much memory, such
	   as a recursion without end.  This could slow your computer and make
	   it hard to even interrupt the program.
	  </para>
        <para>Une fois que la limite est atteinte, l'<application>Outil de maths Genius</application> vous demande si vous voulez interrompre le calcul ou si vous souhaitez continuer. Si vous continuez, aucune limite n'est appliquée et il est possible de saturer la mémoire de l'ordinateur. La limite s'applique à nouveau la prochaine fois que vous exécuterez un programme ou une expression dans la console indépendamment de votre réponse précédente.</para>
        <para>Régler la limite à zéro signifie qu'il n'y a aucune limite sur la quantité de mémoire utilisable par Genius.</para>
	  </listitem>
	</varlistentry>

      </variablelist> 
    </sect1> 

  </chapter>

<!-- ============= About ====================================== -->
  <chapter id="genius-about"> 
    <title>À propos de l'<application>Outil de maths Genius</application></title> 

    <para>L'<application>Outil de maths Genius</application> a été écrit par Jiří (George) Lebl (<email>jirka@5z.com</email>). L'historique de l'<application>Outil de maths Genius</application> commence à la fin de l'année 1997. C'était la première calculatrice pour GNOME, mais il a grossi au point de devenir bien plus qu'une simple calculatrice de bureau. Pour trouver plus d'informations à propos de l'<application>Outil de maths Genius</application>, visitez la <ulink url="http://www.jirka.org/genius.html" type="http">page Web de Genius</ulink>.</para>
    <para>Pour rapporter une anomalie ou émettre une suggestion concernant cette application ou ce manuel, envoyez un courriel à l'auteur ou à la liste de discussion (voir site Web).</para>

    <para> This program is distributed under the terms of the GNU
      General Public license as published by the Free Software
      Foundation; either version 3 of the License, or (at your option)
      any later version. A copy of this license can be found at this
      <ulink url="http://www.gnu.org/copyleft/gpl.html" type="http">link</ulink>, or in the file
      COPYING included with the source code of this program. </para>

    <para>Jiří Lebl was during various parts of the development
      partially supported for the work by NSF grants DMS 0900885, 
      DMS 1362337,
      the University of Illinois at Urbana-Champaign,
      the University of California at San Diego, 
      the University of Wisconsin-Madison, and
      Oklahoma State University.  The software has
      been used for both teaching and research.</para>

  </chapter>

</book>
