Manuel de l'Outil de maths Genius.

# Manuel de Genius

1997-2021
Jiří (George) Lebl
2004
Kai Willadsen

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 lien ou dans le fichier COPYING-DOCS fourni avec le présent manuel.

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.

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.

DOCUMENT AND MODIFIED VERSIONS OF THE DOCUMENT ARE PROVIDED UNDER THE TERMS OF THE GNU FREE DOCUMENTATION LICENSE WITH THE FURTHER UNDERSTANDING THAT:

1. DOCUMENT IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS FREE OF DEFECTS MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY, ACCURACY, AND PERFORMANCE OF THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS WITH YOU. SHOULD ANY DOCUMENT OR MODIFIED VERSION PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL WRITER, AUTHOR OR ANY CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER; AND

2. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE AUTHOR, INITIAL WRITER, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER DAMAGES OR LOSSES ARISING OUT OF OR RELATING TO USE OF THE DOCUMENT AND MODIFIED VERSIONS OF THE DOCUMENT, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES.

Jiří
Lebl
Oklahoma State University

     jiri.lebl@gmail.com

Kai
Willadsen
University of Queensland, Australia

     kaiw@itee.uq.edu.au

0.2
October 2021

Jiri (George) Lebl jiri.lebl@gmail.com

This manual describes version 1.0.27 of Genius.

## Votre avis

To report a bug or make a suggestion regarding the Genius Mathematics Tool application or this manual, please visit the Genius Web page or email me at jiri.lebl@gmail.com.

## Introduction

The Genius Mathematics Tool application is a general calculator for use as a desktop calculator, an educational tool in mathematics and other STEM fields, and has found use in research. The language used in Genius Mathematics Tool is designed to be ‘mathematical’ in the sense that it should be ‘what you mean is what you get’. Of course, that is not an entirely attainable goal. Genius Mathematics Tool features rationals, arbitrary precision integers and multiple precision floats using the GMP library. It handles complex numbers using cartesian notation. It has good vector and matrix manipulation and can handle basic linear algebra. The programming language allows user defined functions, variables, and parameters.

Genius Mathematics Tool comes in two versions. One version is the graphical GNOME version, which features an IDE style interface and the ability to plot functions of one or two variables. Parametric plots of curves are also supported. It can plot slope fields, vector fields and draw their solutions. The plots can be exported to several formats. The command line version does not require GNOME, but does not implement any feature that requires the graphical interface, such as plotting

Parts of this manual describe the graphical version of the calculator. The language that both versions use is the same, it is simply the graphical features such as plotting that are unique to the GUI version.

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

## Premiers pas

### Lancement de l'Outil de maths Genius

You can start Genius Mathematics Tool in the following ways:

Menu Applications

  En fonction de votre système d'exploitation et de sa version, l'élément de menu pour l'Outil de maths Genius peut apparaître à différents endroits. Cela peut être dans les sous-menus Éducation, Accessoires, Bureautique, Science ou d'autres similaires en fonction de vos réglages personnels. Le nom de l'entrée de menu que vous recherchez est Outil de maths Genius. Une fois localisé, cliquez dessus pour démarrer l'Outil de maths Genius.

Boîte de dialogue Lancer une application

  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 Lancer une application et saisir `gnome-genius`.

Ligne de commande

  Pour démarrer la version GNOME de l'Outil de maths Genius, saisissez `gnome-genius`.

  Pour démarrer seulement la version en ligne de commande, exécutez la commande `genius`. Cette version ne comprend pas d'environnement graphique et certaines fonctionnalités comme le tracé de graphiques ne sont pas disponibles.

### Démarrage de Genius

Lorsque vous démarrez la version GNOME de l'Outil de maths Genius, la fenêtre apparaît.

#### Fenêtre de l'Outil de maths Genius

Shows Genius Mathematics Tool main window. Contains titlebar, menubar, toolbar and working area. Menubar contains File, Edit, Calculator, Examples, Programs, Settings, and Help menus.

La fenêtre de l'Outil de maths Genius contient les éléments suivants :

Barre de menus

  Les menus de la barre de menus contiennent toutes les commandes dont vous aurez besoin pour travailler avec les fichiers dans l'Outil de maths Genius. Le menu Fichier contient les éléments pour charger et enregistrer des éléments et créer de nouveaux programmes. La commande Charger et exécuter... n'ouvre pas de nouvelle fenêtre pour le programme mais exécute seulement le programme directement. Elle est équivalente à la commande `load`.

  The Calculator 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 Calculator allows plotting functions using a user friendly dialog box.

  The Examples 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 either some feature of Genius Mathematics Tool or some mathematical concept.

  The Programs menu lists the currently open programs and allows you to switch between them.

  Les autres menus contiennent les mêmes fonctions classiques qui apparaissent dans d'autres applications.

Barre d'outils

  La barre d'outils contient un sous-ensemble des commandes accessibles à partir de la barre de menus.

Zone de travail

  La zone de travail est la principale méthode d'interaction avec l'application.

  The working area initially has just the Console 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.

  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.

## Utilisation de base

### Utilisation de la zone de travail

Normally you interact with the calculator in the Console 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 Genius Mathematics Tool as a calculator only, just type in your expression in the console, it will be evaluated, and the returned value will be printed.

To evaluate an expression, type it into the Console work area and press enter. Expressions are written in a language called GEL. The most simple GEL expressions just looks like mathematics. For example

    genius> 30*70 + 67^3.0 + ln(7) * (88.8/100)

or

    genius> 62734 + 812634 + 77^4 mod 5

or

    genius> | sin(37) - e^7 |

or

    genius> sum n=1 to 70 do 1/n

(Last is the harmonic sum from 1 to 70)

To get a list of functions and commands, type:

    genius> help

If you wish to get more help on a specific function, type:

    genius> help FunctionName

To view this manual, type:

    genius> manual

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 `path/to/program.gel`, type

    genius> load path/to/program.gel

Genius Mathematics Tool keeps track of the current directory. To list files in the current directory type `ls`, to change directory do `cd directory` as in the UNIX command shell.

### Création d'un programme

If you wish to enter several more complicated commands, or perhaps write a complicated function using the GEL language, you can create a new program; really just a file with many commands.

To start writing a new program, choose File New Program. A new tab will appear in the work area. You can write a GEL program in this work area. Once you have written your program you can run it by Calculator Run (or the Run toolbar button). This will execute your program and will display any output on the Console 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. Calculator Run will always run the currently selected program even if you are on the Console tab. The currently selected program has its tab in bold type. To select a program, just click on its tab.

To save the program you've just written, choose File Save As.... Similarly as in other programs you can choose File Save 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 File Save All Unsaved.

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.

### Ouverture et lancement d'un programme

Pour ouvrir un fichier, choisissez Fichier Ouvrir. Un nouvel onglet contenant le fichier apparaît dans la zone de travail. Vous pouvez l'utiliser pour modifier le fichier.

Pour lancer un programme à partir d'un fichier, choisissez Fichier Charger et exécuter.... Le programme est lancé sans être ouvert dans un onglet séparé. C'est équivalent à la commande `load`.

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 File Reload from Disk 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.

## Tracé de graphiques

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 Création de graphiques. Vous pouvez accéder à cette fenêtre, soit en cliquant sur le bouton Tracer de la barre d'outils ou en sélectionnant Tracer dans le menu Calculateur. Vous pouvez également accéder aux fonctionnalités de tracer en utilisant les fonctions de tracé du langage GEL. Consultez pour apprendre comment saisir des expressions compréhensibles par Genius.

### Tracé de lignes

To graph real-valued functions of one variable, open the Create Plot window. You can also use the `LinePlot` function on the command line (see its documentation). And by the words line plot, we mean plots in the plane, as opposed to surface plots, which are in three dimensions.

Une fois que vous avez cliqué sur le bouton Tracer, une fenêtre contenant des onglets apparaît. Vous devez être dans l'onglet Tracé de lignes et dans celui-ci, vous devez être dans l'onglet Fonctions / Expressions (consultez ).

#### Fenêtre Création de graphiques

Shows the line plotting window.

Type expressions with `x` as the independent variable into the textboxes. Alternatively you can give names of functions such as `cos` rather then having to type `cos(x)`. 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. In the boxes for the ranges, simple expressions are allowed, such as `2*pi` or `10^3`. The `y` (dependent) range can be set automatically by turning on the Fit dependent axis checkbox. The names of the variables can also be changed. Pressing the Plot button produces the graph shown in .

The variables can be renamed by clicking the Change variable names... 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.

#### Fenêtre contenant une courbe

The graph produced.

À 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.

Pour tracer à partir de la ligne de commande, consultez la documentation de la fonction `LinePlot`.

### Courbes paramétriques

In the create plot window, you can also choose the Parametric notebook tab to create two dimensional parametric plots. This way you can plot a single parametric function. You can either specify the points as `x` and `y`, or giving a single complex number as a function of the variable `t`. The range of the variable `t` is given explicitly, and the function is sampled according to the given increment. The `x` and `y` range can be set automatically by turning on the Fit dependent axis checkbox, or it can be specified explicitly. See .

#### Onglet pour les courbes paramétriques

Parametric plotting tab in the Create Plot window.

An example of a parametric plot is given in . 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 `LinePlotParametric` or `LinePlotCParametric` function.

#### Courbe paramétrique

Parametric plot produced

### Champ de directions

Dans la fenêtre de création de graphiques, vous pouvez également sélectionner l'onglet Champ de directions 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 `SlopefieldPlot`.

Quand un champ de directions est actif, un menu supplémentaire Solveur 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.

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 `SlopefieldDrawSolution` pour tracer les solutions à partir de la ligne de commande ou dans des programmes.

### Champ de vecteurs

Dans la fenêtre de création de graphiques, vous pouvez également sélectionner l'onglet Champ de vecteurs 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 `VectorfieldPlot`.

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.

Quand un champ de vecteurs est actif, un menu supplémentaire Solveur 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.

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 `VectorfieldDrawSolution` pour tracer les solutions à partir de la ligne de commande ou dans des programmes.

### Tracé de surfaces

Genius can also plot surfaces. Select the Surface plot tab in the main notebook of the Create Plot window. Here you can specify a single expression that should use either `x` and `y` as real independent variables or `z` as a complex variable (where `x` is the real part of `z` and `y` is the imaginary part). For example to plot the modulus of the cosine function for complex parameters, you could enter `|cos(z)|`. This would be equivalent to `|cos(x+1i*y)|`. See . For plotting using the command line see the documentation of the `SurfacePlot` function.

The `z` range can be set automatically by turning on the Fit dependent axis checkbox. The variables can be renamed by clicking the Change variable names... 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.

#### Graphique de surface

Modulus of the complex cosine function.

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 Rotate axis... in the View menu. The View 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 Start rotate animation, to start a continuous slow rotation. This is especially good if using Genius Mathematics Tool to present to an audience.

## Fondamentaux GEL

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. Genius Mathematics Tool 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.

### Types de données

Values in GEL can be numbers, Booleans, or strings. GEL also treats matrices as values. Values can be used in calculations, assigned to variables and returned from functions, among other uses.

#### Nombres

Integers are the first type of number in GEL. Integers are written in the normal way.

    1234

Hexadecimal and octal numbers can be written using C notation. For example:

    0x123ABC
    01234

Or you can type numbers in an arbitrary base using `<base>\<number>`. Digits higher than 10 use letters in a similar way to hexadecimal. For example, a number in base 23 could be written:

    23\1234ABCD

The second type of GEL number is rationals. Rationals are simply achieved by dividing two integers. So one could write:

    3/4

to get three quarters. Rationals also accept mixed fraction notation. So in order to get one and three tenths you could write:

    1 3/10

The next type of number is floating point. These are entered in a similar fashion to C notation. You can use `E`, `e` or `@` as the exponent delimiter. Note that using the exponent delimiter gives a float even if there is no decimal point in the number. Examples:

    1.315
    7.887e77
    7.887e-77
    .3
    0.3
    77e5

When Genius prints a floating point number it will always append a `.0` even if the number is whole. This is to indicate that floating point numbers are taken as imprecise quantities. When a number is written in the scientific notation, it is always a floating point number and thus Genius does not print the `.0`.

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 `i`. Here are examples of entering complex numbers:

    1+2i
    8.01i
    77*e^(1.3i)

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

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

#### Booléens

Genius prend également en charge nativement les données booléennes. Les deux constantes booléennes sont `true` (vrai) et `false` (faux) ; ces identifiants peuvent être utilisés comme n'importe quelle autre variable. Vous pouvez aussi utiliser les identifiants `True`, `TRUE`, `False` et `FALSE` comme alias de ces précédents.

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 `false` et tout autre nombre comme `true`.

In addition, you can do arithmetic with Boolean values. For example:

    ( (1 + true) - false ) * true

is the same as:

    ( (true or true) or not false ) and true

Only addition, subtraction and multiplication are supported. If you mix numbers with Booleans in an expression then the numbers are converted to Booleans as described above. This means that, for example:

    1 == true

always evaluates to `true` since 1 will be converted to `true` before being compared to `true`.

#### Chaînes de caractères

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:

    a=2+3;"The result is: "+a

will create the string:

    The result is: 5

You can also use C-like escape sequences such as `\n`,`\t`,`\b`,`\a` and `\r`. To get a `\` or `"` into the string you can quote it with a `\`. For example:

    "Slash: \\ Quotes: \" Tabs: \t1\t2\t3"

will make a string:

    Slash: \ Quotes: " Tabs: 	1	2	3

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 `print` or `printn` functions.

In addition, you can use the library function `string` to convert anything to a string. For example:

    string(22)

will return

    "22"

Strings can also be compared with `==` (equal), `!=` (not equal) and `<=>` (comparison) operators

#### Null

There is a special value called `null`. No operations can be performed on it, and nothing is printed when it is returned. Therefore, `null` is useful when you do not want output from an expression. The value `null` can be obtained as an expression when you type `.`, the constant `null` or nothing. By nothing we mean that if you end an expression with a separator `;`, it is equivalent to ending it with a separator followed by a `null`.

Example:

    x=5;.
    x=5;

Certaines fonctions renvoient `null` quand aucune valeur ne peut être renvoyée ou quand une erreur survient. La grandeur `null` est aussi utilisée comme vecteur ou matrice vide ou comme une référence vide.

### Utilisation des variables

Syntax:

    VariableName

Example:

    genius> e
    = 2.71828182846

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 ).

#### Utilisation de la complétion à l'aide de la touche Tab

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 `Tab`.

#### Noms de variable sensibles à la casse

Les noms de variable sont sensibles à la casse. Cela signifie que les variables appelées `bonjour`, `BONJOUR` et `Bonjour` sont toutes différentes.

#### Attribution de variables

Syntax:

    <identifier> = <value>
    <identifier> := <value>

Example:

    x = 3
    x := 3

To assign a value to a variable, use the `=` or `:=` operators. These operators set the value of the variable and return the value you set, so you can do things like

    a = b = 5

This will set `b` to 5 and then also set `a` to 5.

Les opérateurs `=` et `:=` peuvent tous les deux être utilisés pour définir des variables. La différence entre les deux est que l'opérateur `:=` agit toujours comme un opérateur d'attribution alors que l'opérateur `=` 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.

For more information about the scope of variables, that is when are what variables visible, see .

#### Variables internes

GEL has a number of built-in ‘variables’, such as `e`, `pi` or `GoldenRatio`. 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 for a full list. Note that `i` 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 `1i`.

#### Variable « Résultat précédent »

The `Ans` and `ans` variables can be used to get the result of the last expression. For example, if you had performed some calculation, to add 389 to the result you could do:

    Ans+389

### Utilisation des fonctions

Syntax:

    FunctionName(argument1, argument2, ...)

Example:

    Factorial(5)
    cos(2*pi)
    gcd(921,317)

To evaluate a function, enter the name of the function, followed by the arguments (if any) to the function in parentheses. This will return the result of applying the function to its arguments. The number of arguments to the function is, of course, different for each function.

There are many built-in functions, such as `sin`, `cos` and `tan`. You can use the `help` built-in command to get a list of available functions, or see for a full listing.

#### Utilisation de la complétion à l'aide de la touche Tab

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 `Tab`.

#### Noms de fonction sensibles à la casse

Les noms des fonctions sont sensibles à la casse. Cela signifie que les fonctions appelées `fairecela`, `FAIRECELA` et `Fairecela` sont toutes différentes.

#### Définition de fonctions

Syntax:

    function <identifier>(<comma separated arguments>) = <function body>
    <identifier> = (`() = <function body>)

The ``` is the backquote character, and signifies an anonymous function. By setting it to a variable name you effectively define a function.

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:

    function addup(a,b,c) = a+b+c

then `addup(1,4,9)` yields 14

#### Liste d'arguments variable

If you include `...` after the last argument name in the function declaration, then Genius will allow any number of arguments to be passed in place of that argument. If no arguments were passed then that argument will be set to `null`. Otherwise, it will be a horizontal vector containing all the arguments. For example:

    function f(a,b...) = b

Then `f(1,2,3)` yields `[2,3]`, while `f(1)` yields a `null`.

#### Une fonction comme argument d'une autre fonction

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.

If you do not enter the parentheses after a function name, instead of being evaluated, the function will instead be returned as a ‘function node’. The function node can then be passed to another function. Example:

    function f(a,b) = a(b)+1;
    function b(x) = x*x;
    f(b,2)

To pass functions that are not defined, you can use an anonymous function (see ). That is, you want to pass a function without giving it a name. Syntax:

    function(<comma separated arguments>) = <function body>
    `(<comma separated arguments>) = <function body>

Example:

    function f(a,b) = a(b)+1;
    f(`(x) = x*x,2)

This will return 5.

#### Opérations sur les fonctions

Some functions allow arithmetic operations, and some single argument functions such as `exp` or `ln`, to operate on the function. For example,

    exp(sin*cos+4)

will return a function that takes `x` and returns `exp(sin(x)*cos(x)+4)`. It is functionally equivalent to typing

    `(x) = exp(sin(x)*cos(x)+4)

This operation can be useful when quickly defining functions. For example to create a function called `f` to perform the above operation, you can just type:

    f = exp(sin*cos+4)

It can also be used in plotting. For example, to plot sin squared you can enter:

    LinePlot(sin^2)

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.

### Séparateur

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 `;` 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:

    3 ; 5

This expression will yield 5.

This will require some parenthesizing to make it unambiguous sometimes, especially if the `;` is not the top most primitive. This slightly differs from other programming languages where the `;` 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 `;` is found at the end of a parenthesis or a block, genius will append a null to it as if you would have written `;null`. This is useful in case you do not want to return a value from a loop, or if you handle the return differently.

If you are typing expressions in a program file you do not have to add a semicolon. In this case genius will simply print the return value whenever it executes the expression. This is the same as when typing on the command line. However, do note that if you are defining a function, the body of the function is a single expression. Usually, therefore, if a function body is long, you will need to enclose it in parentheses.

### Commentaires

GEL is similar to other scripting languages in that `#` denotes a comment, 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,

    # This is just a comment
    # every line in a comment must have its own pound sign
    # in the next line we set x to the value 123
    x=123;

### Évaluation modulaire

Genius implements modular arithmetic. To use it you just add "mod <integer>" after the expression. Example: `2^(5!) * 3^(6!) mod 5` It could be possible to do modular arithmetic by computing with integers and then modding in the end with the `%` operator, which simply gives the remainder, but that may be time consuming if not impossible when working with larger numbers. For example, `10^(10^10) % 6` will simply not work (the exponent will be too large), while `10^(10^10) mod 6` is instantaneous. The first expression first tries to compute the integer `10^(10^10)` and then find remainder after division by 6, while the second expression evaluates everything modulo 6 to begin with.

The inverses of numbers mod some integer are computed by writing them as rational numbers (as long as the desired inverse exists, of course). Examples:

    10^-1 mod 101
    1/10 mod 101

Modular evaluation also works with matrices including taking inverses, powers, and dividing. Example:

    A = [1,2;3,4]
    B = A^-1 mod 5
    A*B mod 5

This should yield the identity matrix as B will be the inverse of A mod 5.

Some functions such as `sqrt` or `log` work in a different way when in modulo mode. These will then work like their discrete versions working within the ring of integers you selected. For example:

    genius> sqrt(4) mod 7
    =
    [2, 5]
    genius> 2*2 mod 7
    = 4

`sqrt` will actually return all the possible square roots.

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 `%` 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.

### Liste des opérateurs GEL

Everything in GEL is really just an expression. Expressions are stringed together with different operators. As we have seen, even the separator is simply a binary operator in GEL. Here is a list of the operators in GEL.

`a;b`

  C'est le séparateur, il évalue simplement à la fois `a` et `b` mais ne renvoie que le résultat de `b`.

`a=b`

  L'opérateur d'attribution. Il attribue `b` à `a` (`a` doit être une valeur à gauche valide). Remarquez que cet opérateur peut être transformé en `==` s'il est utilisé là où une expression booléenne est attendue.

`a:=b`

  L'opérateur d'attribution. Il attribue `b` à `a` (`a` doit être une valeur à gauche valide). Il est différent de `=` car il n'est jamais transformée en `==`.

`|a|`

  Absolute value. In case the expression is a complex number the result will be the modulus (distance from the origin). For example: `|3 * e^(1i*pi)|` returns 3.

  Consultez Mathworld pour plus d'informations.

`a^b`

  Exposant, met `a` à la puissance `b`.

`a.^b`

  Exposant élément par élément. Met chaque élément d'une matrice `a` à la puissance `b`. Si `b` est une matrice de la même taille que `a` alors l'opération se réalise élément par élément. Si `a` est un nombre et `b` est une matrice alors cela crée une matrice de la même taille que `b` contenant `a` mis à la puissance de chaque élément de `b`.

`a+b`

  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.

`a-b`

  Soustraction. Soustrait deux nombres, matrices ou fonctions.

`a*b`

  Multiplication. C'est la multiplication matricielle normale.

`a.*b`

  Multiplication élément par élément si `a` et `b` sont des matrices.

`a/b`

  Division. When `a` and `b` are just numbers this is the normal division. When they are matrices, then this is equivalent to `a*b^-1`.

`a./b`

  Element by element division. Same as `a/b` for numbers, but operates element by element on matrices.

`a\b`

  Division arrière. C'est donc la même chose que `b/a`.

`a.\b`

  Division arrière élément par élément.

`a%b`

  The mod operator. This does not turn on the modular mode, but just returns the remainder of integer division `a/b`.

`a.%b`

  Element by element mod operator. Returns the remainder after element by element integer division `a./b`.

`a mod b`

  Opérateur d'évaluation modulaire. L'expression `a` est évaluée modulo `b`. Consultez . Certaines fonctions et opérateurs se comportent différemment modulo un entier.

`a!`

  Opérateur factoriel. Il s'agit de `1*...*(n-2)*(n-1)*n`.

`a!!`

  Opérateur double factoriel. Il s'agit de `1*...*(n-4)*(n-2)*n`.

`a==b`

  Equality operator. Returns `true` or `false` depending on `a` and `b` being equal or not.

`a!=b`

  Opérateur inégalité, renvoie `true` si `a` n'est pas égal à `b` sinon renvoie `false`.

`a<>b`

  Autre opérateur inégalité, renvoie `true` si `a` n'est pas égal à `b` sinon renvoie `false`.

`a<=b`

  Less than or equal operator, returns `true` if `a` is less than or equal to `b` else returns `false`. These can be chained as in `a <= b <= c` (can also be combined with the less than operator).

`a>=b`

  Greater than or equal operator, returns `true` if `a` is greater than or equal to `b` else returns `false`. These can be chained as in `a >= b >= c` (and they can also be combined with the greater than operator).

`a<b`

  Less than operator, returns `true` if `a` is less than `b` else returns `false`. These can be chained as in `a < b < c` (they can also be combined with the less than or equal to operator).

`a>b`

  Greater than operator, returns `true` if `a` is greater than `b` else returns `false`. These can be chained as in `a > b > c` (they can also be combined with the greater than or equal to operator).

`a<=>b`

  Opérateur comparaison. Si `a` est égal à `b`, cela renvoie 0, si `a` est inférieur à `b`, cela renvoie -1 et si `a` est supérieur à `b`, cela renvoie 1.

`a and b`

  Logical and. Returns true if both `a` and `b` are true, else returns false. If given numbers, nonzero numbers are treated as true.

`a or b`

  Logical or. Returns true if either `a` or `b` is true, else returns false. If given numbers, nonzero numbers are treated as true.

`a xor b`

  Logical xor. Returns true if exactly one of `a` or `b` is true, else returns false. If given numbers, nonzero numbers are treated as true.

`not a`

  Logical not. Returns the logical negation of `a`.

`-a`

  Negation operator. Returns the negative of a number or a matrix (works element-wise on a matrix).

`&a`

  Variable referencing (to pass a reference to a variable). See .

`*a`

  Variable dereferencing (to access a referenced variable). See .

`a'`

  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 `a` is x+iy, then the j,i element of `a'` is x-iy.

`a.'`

  Matrix transpose, does not conjugate the entries. That is, the i,j element of `a` becomes the j,i element of `a.'`.

`a@(b,c)`

  Get element of a matrix in row `b` and column `c`. If `b`, `c` are vectors, then this gets the corresponding rows, columns or submatrices.

`a@(b,)`

  Renvoie une ligne de matrice (ou plusieurs lignes si `b` est un vecteur).

`a@(b,:)`

  Comme ci-dessus.

`a@(,c)`

  Renvoie une colonne de matrice (ou des colonnes si `c` est un vecteur).

`a@(:,c)`

  Comme ci-dessus.

`a@(b)`

  Renvoie un élément d'une matrice en le traitant comme un vecteur. Cela parcourt la matrice dans le sens des lignes.

`a:b`

  Build a vector from `a` to `b` (or specify a row, column region for the `@` operator). For example to get rows 2 to 4 of matrix `A` we could do

      A@(2:4,)

  as `2:4` will return a vector `[2,3,4]`.
`a:b:c`

  Build a vector from `a` to `c` with `b` as a step. That is for example

      genius> 1:2:9
      =
      `[1, 3, 5, 7, 9]

  When the numbers involved are floating point numbers, for example `1.0:0.4:3.0`, 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 `2^-20` 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 `float` if you wish to get floating point numbers in the end. For example `1:2/5:3` does the right thing and `float(1:2/5:3)` even gives you floating point numbers and is ever so slightly more precise than `1.0:0.4:3.0`.

`(a)i`

  Make `a` into an imaginary number (multiply `a` by the imaginary). Normally the imaginary number `i` is written as `1i`. So the above is equal to

      (a)*1i

``a`

  Apostropher un identifiant afin qu'il ne soit pas évalué. Ou apostropher une matrice afin qu'elle ne soit pas étendue.

`a swapwith b`

  Échange la valeur de `a` par la valeur de `b`. Pour le moment, ne fonctionne pas sur des ensembles d'éléments de matrice. Renvoie `null`. Disponible à partir de la version 1.0.13.

`increment a`

  Incrémente la variable `a` de 1. Si `a` est une matrice alors incrémente chaque élément. C'est équivalent à `a=a+1` mais est plus rapide. Renvoie `null`. Disponible à partir de la version 1.0.13.

`increment a by b`

  Incrémente la variable `a` de `b`. Si `a` est une matrice alors incrémente chaque élément. C'est équivalent à `a=a+b` mais est plus rapide. Renvoie `null`. Disponible à partir de la version 1.0.13.

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.

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

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, `-1^k` est bien `(-1)^k`, mais `-foo(1)^k` est bien `-(foo(1)^k)`. En conséquence, faites attention à son utilisation et, en cas de doute, ajoutez des parenthèses.

## Programmation avec GEL

### Tests

Syntax:

    if <expression1> then <expression2> [else <expression3>]

If `else` is omitted, then if the `expression1` yields `false` or 0, `NULL` is returned.

Examples:

    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 )

Note that `=` will be translated to `==` if used inside the expression for `if`, so

    if a=5 then a=a-1

will be interpreted as:

    if a==5 then a:=a-1

### Boucles

#### Boucles tant que (while) et jusqu'à (until)

Syntax:

    while <expression1> do <expression2>
    until <expression1> do <expression2>
    do <expression2> while <expression1>
    do <expression2> until <expression1>

These are similar to other languages. However, as in GEL it is simply an expression that must have some return value, these constructs will simply return the result of the last iteration or `NULL` if no iteration was done. In the boolean expression, `=` is translated into `==` just as for the `if` statement.

#### Boucles pour (for)

Syntax:

    for <identifier> = <from> to <to> do <body>
    for <identifier> = <from> to <to> by <increment> do <body>

Loop with identifier being set to all values from `<from>` to `<to>`, optionally using an increment other than 1. These are faster, nicer and more compact than the normal loops such as above, but less flexible. The identifier must be an identifier and can't be a dereference. The value of identifier is the last value of identifier, or `<from>` if body was never evaluated. The variable is guaranteed to be initialized after a loop, so you can safely use it. Also the `<from>`, `<to>` and `<increment>` must be non complex values. The `<to>` is not guaranteed to be hit, but will never be overshot, for example the following prints out odd numbers from 1 to 19:

    for i = 1 to 20 by 2 do print(i)

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

    for x = 0 to 1 by 0.1 do print(x)

does the expected even though adding 0.1 ten times becomes just slightly more than 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:

    for x = 0 to 1 by 1/10 do print(x)

This check is done only from version 1.0.16 onwards, so execution of your code may differ on older versions.

#### Boucles pour chaque (foreach)

Syntax:

    for <identifier> in <matrix> do <body>

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:

    for n in [1,2:3,4] do print(n)

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,

    for n in RowsOf ([1,2:3,4]) do print(n)

will print out [1,2] and then [3,4].

#### Instructions « break » et « continue »

You can also use the `break` and `continue` commands in loops. The continue `continue` command will restart the current loop at its next iteration, while the `break` command exits the current loop.

    while(<expression1>) do (
      if(<expression2>) break
      else if(<expression3>) continue;
      <expression4>
    )

### Sommes et produits

Syntax:

    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>

If you substitute `for` with `sum` or `prod`, then you will get a sum or a product instead of a `for` loop. Instead of returning the last value, these will return the sum or the product of the values respectively.

Si aucun contenu (body) est exécuté (par exemple, `sum i=1 to 0 do ...`) alors la convention standard est que `sum` renvoie 0 et `prod` renvoie 1.

For floating point numbers the same roundoff error protection is done as in the for loop. See .

### Opérateurs de comparaison

Les opérateurs de comparaison standard suivants sont pris en charge dans GEL et ont des significations évidentes : `==`, `>=`, `<=`, `!=`, `<>`, `<`, `>`. Ils renvoient `true` ou `false`. Les opérateurs `!=` et `<>` sont les mêmes et signifient « n'est pas égal à ». GEL comprend également l'opérateur `<=>` 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.

Normally `=` is translated to `==` if it happens to be somewhere where GEL is expecting a condition such as in the if condition. For example

    if a=b then c
    if a==b then c

are the same thing in GEL. However you should really use `==` or `:=` when you want to compare or assign respectively if you want your code to be easy to read and to avoid mistakes.

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

Pour construire des expressions logiques, utilisez les mots `not`, `and`, `or`, `xor`. Les opérateurs `or` et `and` 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 : `1 or a=1` n'effectue pas l'attribution `a=1` puisque le premier argument est vrai (true).

### Variables globales et portée des variables

GEL is a dynamically scoped language. We will explain what this means below. That is, normal variables and functions are dynamically scoped. The exception are parameter variables, which are always global.

Like most programming languages, GEL has different types of variables. Normally when a variable is defined in a function, it is visible from that function and from all functions that are called (all higher contexts). For example, suppose a function `f` defines a variable `a` and then calls function `g`. Then function `g` can reference `a`. But once `f` returns, the variable `a` goes out of scope. For example, the following code will print out 5. The function `g` cannot be called on the top level (outside `f` as `a` will not be defined).

    function f() = (a:=5; g());
    function g() = print(a);
    f();

If you define a variable inside a function it will override any variables defined in calling functions. For example, we modify the above code and write:

    function f() = (a:=5; g());
    function g() = print(a);
    a:=10;
    f();

This code will still print out 5. But if you call `g` outside of `f` then you will get a printout of 10. Note that setting `a` to 5 inside `f` does not change the value of `a` at the top (global) level, so if you now check the value of `a` it will still be 10.

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.

Functions are treated exactly like variables. Hence you can locally redefine functions. Normally (on the top level) you cannot redefine protected variables and functions. But locally you can do this. Consider the following session:

    genius> function f(x) = sin(x)^2
    = (`(x)=(sin(x)^2))
    genius> function f(x) = sin(x)^2
    = (`(x)=(sin(x)^2))
    genius> function g(x) = ((function sin(x)=x^10);f(x))
    = (`(x)=((sin:=(`(x)=(x^10)));f(x)))
    genius> g(10)
    = 1e20

Functions and variables defined at the top level are considered global. They are visible from anywhere. As we said the following function `f` will not change the value of `a` to 5.

    a=6;
    function f() = (a:=5);
    f();

Sometimes, however, it is necessary to set a global variable from inside a function. When this behavior is needed, use the `set` function. Passing a string or a quoted identifier to this function sets the variable globally (on the top level). For example, to set `a` to the value 3 you could call:

    set(`a,3)

or:

    set("a",3)

La fonction `set` 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.

See also the `SetElement` and `SetVElement` functions.

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é.

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 True Local Variables and Returning Functions.

### Variables paramètres

As we said before, there exist special variables called parameters that exist in all scopes. To declare a parameter called `foo` with the initial value 1, we write

    parameter foo = 1

From then on, `foo` is a strictly global variable. Setting `foo` inside any function will modify the variable in all contexts, that is, functions do not have a private copy of parameters.

When you undefine a parameter using the `undefine` function, it stops being a parameter.

Some parameters are built-in and modify the behavior of genius.

### Sortie de fonction

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é `return`. `Return` prend un seul argument qui est la valeur renvoyée.

Example:

    function f(x) = (
      y=1;
      while true do (
        if x>50 then return y;
        y=y+1;
        x=x+1
      )
    )

### Références

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.

When using functions that return values through references in the argument list, just pass the variable name with an ampersand. For example the following code will compute an eigenvalue of a matrix `A` with initial eigenvector guess `x`, and store the computed eigenvector into the variable named `v`:

    RayleighQuotientIteration (A,x,0.001,100,&v)

Les détails concernant le fonctionnement des références et leur syntaxe sont similaires à ceux du langage C. L'opérateur `&` référence une variable et `*` la déréférence. Les deux ne peuvent s'appliquer que sur un identifiant, par conséquent `**a` n'est pas une expression légale en GEL.

References are best explained by an example:

    a=1;
    b=&a;
    *b=2;

now `a` contains 2. You can also reference functions:

    function f(x) = x+1;
    t=&f;
    *t(3)

gives us 4.

### Valeurs à gauche (lvalues)

An lvalue is the left hand side of an assignment. In other words, an lvalue is what you assign something to. Valid lvalues are:

`a`

  Identifier. Here we would be setting the variable of name `a`.

`*a`

  Dereference of an identifier. This will set whatever variable `a` points to.

`a@(<region>)`

  A region of a matrix. Here the region is specified normally as with the regular @() operator, and can be a single entry, or an entire region of the matrix.

Examples:

    a:=4
    *tmp := 89
    a@(1,1) := 5
    a@(4:8,3) := [1,2,3,4,5]'

Note that both `:=` and `=` can be used interchangeably. Except if the assignment appears in a condition. It is thus always safer to just use `:=` when you mean assignment, and `==` when you mean comparison.

## Programmation avancée avec GEL

### Gestion des erreurs

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 `bailout`. Si quelque chose se passe vraiment mal et que vous voulez interrompre complètement le calcul actuel, vous pouvez utiliser l'instruction `exception`.

For example if you want to check for arguments in your function. You could use the following code.

    function f(M) = (
      if not IsMatrix (M) then (
        error ("M not a matrix!");
        bailout
      );
      ...
    )

### Syntaxe de haut-niveau

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 a sequence of lines as if they 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 part of several statements inside parentheses). When a statement does not end with a separator on the top level, the result is printed after being executed.

For example,

    function f(x)=x^2
    f(3)

will print first the result of setting a function (a representation of the function, in this case `(`(x)=(x^2))`) and then the expected 9. To avoid this, enter a separator after the function definition.

    function f(x)=x^2;
    f(3)

If you need to put a separator into your function then you have to surround with parenthesis. For example:

    function f(x)=(
      y=1;
      for j=1 to x do
        y = y+j;
      y^2
    );

The following code will produce an error when entered on the top level of a program, while it will work just fine in a function.

    if Something() then
      DoSomething()
    else
      DoSomethingElse()

The problem is that after Genius Mathematics Tool sees the end of line after the second line, it will decide that we have whole statement and it will execute it. After the execution is done, Genius Mathematics Tool will go on to the next line, it will see `else`, and it will produce a parsing error. To fix this, use parentheses. Genius Mathematics Tool will not be satisfied until it has found that all parentheses are closed.

    if Something() then (
      DoSomething()
    ) else (
      DoSomethingElse()
    )

### Renvoi de fonction

It is possible to return functions as value. This way you can build functions that construct special purpose functions according to some parameters. The tricky bit is what variables does the function see. The way this works in GEL is that when a function returns another function, all identifiers referenced in the function body that went out of scope are prepended a private dictionary of the returned function. So the function will see all variables that were in scope when it was defined. For example, we define a function that returns a function that adds 5 to its argument.

    function f() = (
      k = 5;
      `(x) = (x+k)
    )

Notice that the function adds `k` to `x`. You could use this as follows.

    g = f();
    g(5)

And `g(5)` should return 10.

One thing to note is that the value of `k` that is used is the one that's in effect when the `f` returns. For example:

    function f() = (
      k := 5;
      function r(x) = (x+k);
      k := 10;
      r
    )

will return a function that adds 10 to its argument rather than 5. This is because the extra dictionary is created only when the context in which the function was defined ends, which is when the function `f` returns. This is consistent with how you would expect the function `r` to work inside the function `f` according to the rules of scope of variables in GEL. Only those variables are added to the extra dictionary that are in the context that just ended and no longer exists. Variables used in the function that are in still valid contexts will work as usual, using the current value of the variable. The only difference is with global variables and functions. All identifiers that referenced global variables at time of the function definition are not added to the private dictionary. This is to avoid much unnecessary work when returning functions and would rarely be a problem. For example, suppose that you delete the "k=5" from the function `f`, and at the top level you define `k` to be say 5. Then when you run `f`, the function `r` will not put `k` into the private dictionary because it was global (toplevel) at the time of definition of `r`.

Sometimes it is better to have more control over how variables are copied into the private dictionary. Since version 1.0.7, you can specify which variables are copied into the private dictionary by putting extra square brackets after the arguments with the list of variables to be copied separated by commas. If you do this, then variables are copied into the private dictionary at time of the function definition, and the private dictionary is not touched afterwards. For example

    function f() = (
      k := 5;
      function r(x) [k] = (x+k);
      k := 10;
      r
    )

will return a function that when called will add 5 to its argument. The local copy of `k` was created when the function was defined.

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 `f` to see the value of `k` from the toplevel despite there being a local variable of the same name during definition. So the code

    function f() = (
      k := 5;
      function r(x) [] = (x+k);
      r
    );
    k := 10;
    g = f();
    g(10)

will return 20 and not 15, which would happen if `k` with a value of 5 was added to the private dictionary.

### Variables locales vraies

When passing functions into other functions, the normal scoping of variables might be undesired. For example:

    k := 10;
    function r(x) = (x+k);
    function f(g,x) = (
      k := 5;
      g(x)
    );
    f(r,1)

you probably want the function `r` when passed as `g` into `f` to see `k` as 10 rather than 5, so that the code returns 11 and not 6. However, as written, the function when executed will see the `k` that is equal to 5. There are two ways to solve this. One would be to have `r` get `k` in a private dictionary using the square bracket notation section Returning Functions.

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 `k` as a local variable in the function `f`. To do this add a `local` 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,

    function f(g,x) = (
      local g,x,k;
      k := 5;
      g(x)
    );

Then the code will work as expected and prints out 11. Note that the `local` statement initializes all the referenced variables (except for function arguments) to a `null`.

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. So the following definition of `f` will also work:

    function f(g,x) = (
      local *;
      k := 5;
      g(x)
    );

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.

### Procédure de démarrage de GEL

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 `lib.cgel`), puis il recherche dans le répertoire actuel, puis il essaye de charger un fichier non compilé appelé `~/.geniusinit`.

If you ever change the library in its installed place, you’ll have to first compile it with `genius --compile loader.gel > lib.cgel`

### Chargement de programmes

Sometimes you have a larger program you wrote into a file and want to read that file into Genius Mathematics Tool. In these situations, you have two options. You can keep the functions you use most inside the `~/.geniusinit` file. Or if you want to load up a file in a middle of a session (or from within another file), you can type `load <list of filenames>` 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:

    load program1.gel program2.gel
    load "Weird File Name With SPACES.gel"

There are also `cd`, `pwd` and `ls` commands built in. `cd` will take one argument, `ls` will take an argument that is like the glob in the UNIX shell (i.e., you can use wildcards). `pwd` takes no arguments. For example:

    cd directory_with_gel_programs
    ls *.gel

## Matrices en GEL

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

### Saisie de matrices

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

    [1,2,3;4,5,6;7,8,9]

or

    [1, 2, 3
     4, 5, 6
     7, 8, 9]

Do not use both ';' and return at once on the same line though.

You can also use the matrix expansion functionality to enter matrices. For example you can do:

    a = [ 1, 2, 3
          4, 5, 6
          7, 8, 9]
    b = [ a,  10
          11, 12]

and you should get

    [1,   2,  3, 10
     4,   5,  6, 10
     7,   8,  9, 10
     11, 11, 11, 12]

similarly you can build matrices out of vectors and other stuff like that.

Another thing is that non-specified spots are initialized to 0, so

    [1, 2, 3
     4, 5
     6]

will end up being

    [1, 2, 3
     4, 5, 0
     6, 0, 0]

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

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

### Opérateur de transposition conjuguée et de transposition

You can conjugate transpose a matrix by using the `'` operator. That is the entry in the `i`th column and the `j`th row will be the complex conjugate of the entry in the `j`th column and the `i`th row of the original matrix. For example:

    [1,2,3]*[4,5,6]'

We transpose the second vector to make matrix multiplication possible. If you just want to transpose a matrix without conjugating it, you would use the `.'` operator. For example:

    [1,2,3]*[4,5,6i].'

Remarquez que la transposée normale, c'est-à-dire l'opérateur `.'`, 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 `.'` lorsque vous travaillez avec des matrices et des vecteurs non complexes.

### Algèbre linéaire

Genius implémente beaucoup de routines utiles d'algèbre linéraire et de manipulation de matrice. Consultez les sections Algèbre linéaire et Manipulation de matrice dans la liste des fonctions GEL.

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.

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.

In general when Genius computes the basis of a certain vectorspace (for example with the `NullSpace`) 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.

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 `rref` will be very fast.

## Polynômes en GEL

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.

### Utilisation des polynômes

Currently polynomials in one variable are just horizontal vectors with value only nodes. The power of the term is the position in the vector, with the first position being 0. So,

    [1,2,3]

translates to a polynomial of

    1 + 2*x + 3*x^2

You can add, subtract and multiply polynomials using the `AddPoly`, `SubtractPoly`, and `MultiplyPoly` functions respectively. You can print a polynomial using the `PolyToString` function. For example,

    PolyToString([1,2,3],"y")

gives

    3*y^2 + 2*y + 1

You can also get a function representation of the polynomial so that you can evaluate it. This is done by using `PolyToFunction`, which returns an anonymous function.

    f = PolyToFunction([0,1,1])
    f(2)

Il est aussi possible de trouver les racines des polynômes de degré 1 à 4 en utilisant la fonction `PolynomialRoots` 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 `FindRootBisection`, `FindRootFalsePosition`, `FindRootMullersMethod` ou `FindRootSecant`.

Consultez dans la liste des fonctions pour le reste des fonctions agissant sur les polynômes.

## Théorie des ensembles en GEL

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.

### Utilisation des ensembles

Tout comme les vecteurs, les objets dans les ensembles peuvent comprendre des nombres, des chaînes de caractères, `null`, 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 `0` et `0.0` comme deux éléments différents. La constante `null` est traitée comme un ensemble vide.

To build a set out of a vector, use the `MakeSet` function. Currently, it will just return a new vector where every element is unique.

    genius> MakeSet([1,2,2,3])
    = [1, 2, 3]

Similarly there are functions `Union`, `Intersection`, `SetMinus`, which are rather self explanatory. For example:

    genius> Union([1,2,3], [1,2,4])
    = [1, 2, 4, 3]

Note that no order is guaranteed for the return values. If you wish to sort the vector you should use the `SortVector` function.

For testing membership, there are functions `IsIn` and `IsSubset`, which return a boolean value. For example:

    genius> IsIn (1, [0,1,2])
    = true

The input `IsIn(x,X)` is equivalent to `IsSubset([x],X)`. Note that since the empty set is a subset of every set, `IsSubset(null,X)` is always true.

## Liste des fonctions GEL

To get help on a specific function from the console type:

    help FunctionName

### Commandes

help

      help

      help NomDeLaFonction

  Affiche l'aide (ou l'aide d'une fonction/commande).

load

      load "fichier.gel"

  Load a file into the interpreter. The file will execute as if it were typed onto the command line.

cd

      cd /nom/de/repertoire

  Change le répertoire de travail en `/nom/de/repertoire`.

pwd

      pwd

  Affiche le répertoire de travail.

ls

      ls

  Affiche les fichiers dans le répertoire.

plugin

      plugin nom_du_greffon

  Charge un greffon. Le greffon portant ce nom doit être installé sur votre système dans le répertoire correct.

### Basique

AskButtons

      AskButtons (requête)

      AskButtons (requête, bouton1, ...)

  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 `null` est renvoyé. L'exécution du programme est bloqué jusqu'à ce que l'utilisateur réponde.

  Version 1.0.10 onwards.

AskString

      AskString (requête)

      AskString (requête, défaut)

  Asks a question and lets the user enter a string, which it then returns. If the user cancels or closes the window, then `null` is returned. The execution of the program is blocked until the user responds. If `default` is given, then it is pre-typed in for the user to just press enter on (version 1.0.6 onwards).

Compose

      Compose (f,g)

  Compose deux fonctions et renvoie une fonction qui est la composition de `f` par `g`.

ComposePower

      ComposePower (f,n,x)

  Compose and execute a function with itself `n` times, passing `x` as argument. Returning `x` if `n` equals 0. Example:

      genius> function f(x) = x^2 ;
      genius> ComposePower (f,3,7)
      = 5764801
      genius> f(f(f(7)))
      = 5764801

Evaluate

      Evaluate (chaîne)

  Analyse et évalue une chaîne.

GetCurrentModulo

      GetCurrentModulo

  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 `mod`) 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.

Identity

      Identity (x)

  Identity function, returns its argument. It is equivalent to `function Identity(x)=x`.

IntegerFromBoolean

      IntegerFromBoolean (val_bool)

  Crée un entier (0 pour `false` ou 1 pour `true`) à partir d'une valeur booléenne. `val_bool` peut également être un nombre et dans ce cas une valeur non nulle est interprétée comme `true` et zéro est interprété comme `false`.

IsBoolean

      IsBoolean (param)

  Vérifie que l'argument est un booléen (et pas un nombre).

IsDefined

      IsDefined (id)

  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.

IsFunction

      IsFunction (param)

  Vérifie que l'argument est une fonction.

IsFunctionOrIdentifier

      IsFunctionOrIdentifier (param)

  Vérifie que l'argument est une fonction ou un identificateur.

IsFunctionRef

      IsFunctionRef (param)

  Vérifie que l'argument est une référence de fonction. Cela inclut les références de variable.

IsMatrix

      IsMatrix (param)

  Vérifie que l'argument est une matrice. Même si `null` est parfois considéré comme une matrice vide, la fonction `IsMatrix` ne considère pas `null` comme une matrice.

IsNull

      IsNull (param)

  Vérifie que l'argument est `null`.

IsString

      IsString (param)

  Vérifie que l'argument est une chaîne de caractères.

IsValue

      IsValue (param)

  Vérifie que l'argument est un nombre.

Parse

      Parse (chaîne)

  Analyse mais n'évalue pas une chaîne de caractères. Notez que certains pré-calculs sont effectués pendant l'étape d'évaluation.

SetFunctionFlags

      SetFunctionFlags (id,drapeau...)

  Définit des drapeaux pour une fonction, actuellement `« PropagateMod »` et `« NoModuloArguments »`. Si `« PropagateMod »` 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 `mod`). Si `« NoModuloArguments »` est défini alors les arguments de la fonction ne sont jamais évalués en arithmétique modulaire.

SetHelp

      SetHelp (id,categorie,desc)

  Définit une catégorie et une ligne de description d'aide pour une fonction.

SetHelpAlias

      SetHelpAlias (id,alias)

  Met en place un pseudonyme pour l'aide.

chdir

      chdir (rep)

  Change le répertoire actuel, tout comme la commande `cd`.

CurrentTime

      CurrentTime

  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.

  Version 1.0.15 onwards.

display

      display (chaîne,expr)

  Affiche une chaîne de caractères et une expression séparées par deux points.

DisplayVariables

      DisplayVariables (var1,var2,...)

  Display set of variables. The variables can be given as strings or identifiers. For example:

      DisplayVariables(`x,`y,`z)

  If called without arguments (must supply empty argument list) as

      DisplayVariables()

  then all variables are printed including a stacktrace similar to Show user variables in the graphical version.

  Version 1.0.18 onwards.

error

      error (chaîne)

  Affiche une chaîne vers la sortie erreur (dans la console).

exit

      exit

  Alias : `quit`

  Quitte le programme.

false

      false

  Aliases: `False` `FALSE`

  La valeur booléenne `false` (faux).

manual

      manual

  Affiche le manuel utilisateur.

print

      print (chaîne)

  Affiche une expression suivie d'un retour à la ligne. L'argument `chaine` peut être n'importe quelle expression. Elle est transformée en chaîne avant d'être affichée.

printn

      printn (chaîne)

  Affiche une expression non suivie d'un retour à la ligne. L'argument `chaine` peut être n'importe quelle expression. Elle est transformée en chaîne avant d'être affichée.

PrintTable

      PrintTable (f,v)

  Print a table of values for a function. The values are in the vector `v`. You can use the vector building notation as follows:

      PrintTable (f,[0:10])

  If `v` is a positive integer, then the table of integers from 1 up to and including v will be used.

  Version 1.0.18 onwards.

protect

      protect (id)

  Protège une variable de la modification. C'est utilisé dans les fonctions internes de GEL pour leur éviter d'être accidentellement écrasées.

ProtectAll

      ProtectAll ()

  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'Outil de maths Genius considère que les variables non protégées sont définies par l'utilisateur.

  Version 1.0.7 onwards.

set

      set (id,val)

  Set a global variable. The `id` can be either a string or a quoted identifier. For example:

      set(`x,1)

  will set the global variable `x` to the value 1.

  The function returns the `val`, to be usable in chaining.

SetElement

      SetElement (id,row,col,val)

  Set an element of a global variable which is a matrix. The `id` can be either a string or a quoted identifier. For example:

      SetElement(`x,2,3,1)

  will set the second row third column element of the global variable `x` 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.

  The `row` and `col` can also be ranges, and the semantics are the same as for regular setting of the elements with an equals sign.

  The function returns the `val`, to be usable in chaining.

  Available from 1.0.18 onwards.

SetVElement

      SetElement (id,elt,val)

  Set an element of a global variable which is a vector. The `id` can be either a string or a quoted identifier. For example:

      SetElement(`x,2,1)

  will set the second element of the global vector variable `x` 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.

  The `elt` can also be a range, and the semantics are the same as for regular setting of the elements with an equals sign.

  The function returns the `val`, to be usable in chaining.

  Available from 1.0.18 onwards.

string

      string (s)

  Crée une chaîne de caractères à partir de n'importe quel argument.

true

      true

  Aliases: `True` `TRUE`

  La valeur booléenne `true` (vrai).

undefine

      undefine (id)

  Alias : `Undefine`

  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.

UndefineAll

      UndefineAll ()

  Annule la définition de toutes les variables globales non protégées (y compris les fonctions et les paramètres). Normalement l'Outil de maths Genius considère que les variables protégées sont des variables et des fonctions définies par le système. Notez que `UndefineAll` 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.

  Version 1.0.7 onwards.

unprotect

      unprotect (id)

  Annule la protection d'une variable contre sa modification.

UserVariables

      UserVariables ()

  Renvoie un vecteur d'identifiants des variables globales définies par l'utilisateur (non protégées).

  Version 1.0.7 onwards.

wait

      wait (secs)

  Attend un nombre spécifié de secondes. `secs` 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.

  Since version 1.0.18, `secs` can be a noninteger number, so `wait(0.1)` will wait for one tenth of a second.

version

      version

  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.

warranty

      warranty

  Renvoie les informations sur la garantie.

### Paramètres

ChopTolerance

      ChopTolerance = nombre

  Tolérance pour la fonction `Chop`.

ContinuousNumberOfTries

      ContinuousNumberOfTries = nombre

  Nombre d'itérations à essayer pour rechercher la continuité et les limites d'une fonction.

ContinuousSFS

      ContinuousSFS = nombre

  Nombre d'étapes successives pour atteindre la tolérance pour le calcul de la continuité.

ContinuousTolerance

      ContinuousTolerance = nombre

  Tolérance pour la continuité d'une fonction et pour le calcul de la limite.

DerivativeNumberOfTries

      DerivativeNumberOfTries = nombre

  Nombre d'itérations à essayer pour trouver la limite pour la dérivée.

DerivativeSFS

      DerivativeSFS = nombre

  Nombre d'étapes successives pour atteindre la tolérance pour le calcul de la dérivée.

DerivativeTolerance

      DerivativeTolerance = nombre

  Tolérance pour le calcul de la dérivée des fonctions.

ErrorFunctionTolerance

      ErrorFunctionTolerance = nombre

  Tolerance of the `ErrorFunction`.

FloatPrecision

      FloatPrecision = nombre

  Précision en virgule flottante.

FullExpressions

      FullExpressions = booléen

  Affiche les expressions complètes, même celles de plus d'une ligne.

GaussDistributionTolerance

      GaussDistributionTolerance = nombre

  Tolerance of the `GaussDistribution` function.

IntegerOutputBase

      IntegerOutputBase = nombre

  Base de sortie pour les entiers.

IsPrimeMillerRabinReps

      IsPrimeMillerRabinReps = nombre

  Number of extra Miller-Rabin tests to run on a number before declaring it a prime in `IsPrime`.

LinePlotDrawLegends

      LinePlotDrawLegends = true

  Indique à genius de tracer les légendes pour les fonctions de tracé de graphiques telles que `LinePlot`.

LinePlotDrawAxisLabels

      LinePlotDrawAxisLabels = true

  Tells genius to draw the axis labels for line plotting functions such as `LinePlot`.

  Version 1.0.16 onwards.

LinePlotVariableNames

      LinePlotVariableNames = ["x","y","z","t"]

  Indique à Genius les noms des variables utilisés pour les fonctions de tracé de graphiques telles que `LinePlot` et autres.

  Version 1.0.10 onwards.

LinePlotWindow

      LinePlotWindow = [x1,x2,y1,y2]

  Définit les limites pour les fonctions de tracé de graphiques telles que `LinePlot`.

MaxDigits

      MaxDigits = nombre

  Nombre maximum de chiffres à afficher.

MaxErrors

      MaxErrors = nombre

  Nombre maximum d'erreurs à afficher.

MixedFractions

      MixedFractions = booléen

  Si vrai, les fractions mixtes sont affichées.

NumericalIntegralFunction

      NumericalIntegralFunction = fonction

  The function used for numerical integration in `NumericalIntegral`.

NumericalIntegralSteps

      NumericalIntegralSteps = nombre

  Steps to perform in `NumericalIntegral`.

OutputChopExponent

      OutputChopExponent = nombre

  Lorsqu'un autre nombre dans l'objet qui est affiché (une matrice ou une valeur) est plus grand que 10-OutputChopWhenExponent et que le nombre actuellement affiché est inférieur à 10-OutputChopExponent alors afficher `0.0` au lieu du nombre.

  La sortie n'est jamais tronquée si `OutputChopExponent` vaut zéro. Cela doit être un nombre entier positif.

  Si vous voulez toujours que la sortie soit tronquée selon `OutputChopExponent` alors définissez `OutputChopWhenExponent` à quelque chose de supérieur ou égal à `OutputChopExponent`.

OutputChopWhenExponent

      OutputChopWhenExponent = nombre

  Définit quand la sortie est tronquée. Consultez `OutputChopExponent`.

OutputStyle

      OutputStyle = chaîne

  Style des affichages, cela peut être `normal`, `latex`, `mathml` ou `troff`.

  This affects mostly how matrices and fractions are printed out and is useful for pasting into documents. For example you can set this to the latex by:

      OutputStyle = "latex"

ResultsAsFloats

      ResultsAsFloats = booléen

  Convertit tous les résultats en nombres flottants avant de les afficher.

ScientificNotation

      ScientificNotation = booléen

  Utilise la notation scientifique.

SlopefieldTicks

      SlopefieldTicks = [verticale,horizontale]

  Définit le nombre de petits traits verticaux et horizontaux dans un graphique de champ de tangente (consultez `SlopefieldPlot`).

  Version 1.0.10 onwards.

SumProductNumberOfTries

      SumProductNumberOfTries = nombre

  How many iterations to try for `InfiniteSum` and `InfiniteProduct`.

SumProductSFS

      SumProductSFS = nombre

  How many successive steps to be within tolerance for `InfiniteSum` and `InfiniteProduct`.

SumProductTolerance

      SumProductTolerance = nombre

  Tolerance for `InfiniteSum` and `InfiniteProduct`.

SurfacePlotDrawLegends

      SurfacePlotDrawLegends = true

  Tells genius to draw the legends for surface plotting functions such as `SurfacePlot`.

  Version 1.0.16 onwards.

SurfacePlotVariableNames

      SurfacePlotVariableNames = ["x","y","z"]

  Tells genius which variable names are used as default names for surface plotting functions using `SurfacePlot`. Note that the `z` does not refer to the dependent (vertical) axis, but to the independent complex variable `z=x+iy`.

  Version 1.0.10 onwards.

SurfacePlotWindow

      SurfacePlotWindow = [x1,x2,y1,y2,z1,z2]

  Définit les limites pour les tracés de surface (consultez `SurfacePlot`).

VectorfieldNormalized

      VectorfieldNormalized = true

  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 `VectorfieldPlot`).

VectorfieldTicks

      VectorfieldTicks = [verticale,horizontale]

  Définit le nombre de petits traits verticaux et horizontaux dans un graphique de champ de vecteurs (consultez `VectorfieldPlot`).

  Version 1.0.10 onwards.

### Constantes

CatalanConstant

      CatalanConstant

  Constante de Catalan, approximativement 0,915..., elle est définie comme la série des termes `(-1^k)/((2*k+1)^2)` où `k` va de 0 à l'infini.

  See Wikipedia or Mathworld for more information.

EulerConstant

      EulerConstant

  Alias : `gamma`

  Euler's constant gamma. Sometimes called the Euler-Mascheroni constant.

  See Wikipedia or Planetmath or Mathworld for more information.

GoldenRatio

      GoldenRatio

  Le nombre d'or.

  See Wikipedia or Planetmath or Mathworld for more information.

Gravity

      Gravity

  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.

  See Wikipedia for more information.

e

      e

  The base of the natural logarithm. `e^x` is the exponential function `exp`. 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: `EulerConstant`.

  See Wikipedia or Planetmath or Mathworld for more information.

pi

      pi

  Le nombre pi, c'est-à-dire le rapport de la circonférence d'un cercle sur son diamètre. Il vaut approximativement 3.14159265359...

  See Wikipedia or Planetmath or Mathworld for more information.

### Nombres

AbsoluteValue

      AbsoluteValue (x)

  Alias : `abs`

  Absolute value of a number and if `x` is a complex value the modulus of `x`. I.e. this the distance of `x` to the origin. This is equivalent to `|x|`.

  See Wikipedia, Planetmath (absolute value), Planetmath (modulus), Mathworld (absolute value) or Mathworld (complex modulus) for more information.

Chop

      Chop (x)

  Remplace les très petits nombres par zéro.

ComplexConjugate

      ComplexConjugate (z)

  Aliases: `conj` `Conj`

  Calcule le conjugué du nombre complexe `z`. Si `z` est un vecteur ou une matrice, tous les éléments sont conjugués.

  See Wikipedia for more information.

Denominator

      Denominator (x)

  Renvoie le dénominateur d'un nombre rationnel.

  See Wikipedia for more information.

FractionalPart

      FractionalPart (x)

  Renvoie la partie fractionnelle d'un nombre.

  See Wikipedia for more information.

Im

      Im (z)

  Alias : `ImaginaryPart`

  Get the imaginary part of a complex number. For example `Re(3+4i)` yields 4.

  See Wikipedia for more information.

IntegerQuotient

      IntegerQuotient (m,n)

  Division sans reste.

IsComplex

      IsComplex (nbre)

  Check if argument is a complex (non-real) number. Do note that we really mean nonreal number. That is, `IsComplex(3)` yields false, while `IsComplex(3-1i)` yields true.

IsComplexRational

      IsComplexRational (nbre)

  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 ».

IsFloat

      IsFloat (nbre)

  Check if argument is a real floating point number (non-complex).

IsGaussInteger

      IsGaussInteger (nbre)

  Alias : `IsComplexInteger`

  Check if argument is a possibly complex integer. That is a complex integer is a number of the form `n+1i*m` where `n` and `m` are integers.

IsInteger

      IsInteger (nbre)

  Vérifie si l'argument est un entier (non complexe).

IsNonNegativeInteger

      IsNonNegativeInteger (nbre)

  Check if argument is a non-negative real integer. That is, either a positive integer or zero.

IsPositiveInteger

      IsPositiveInteger (nbre)

  Alias : `IsNaturalNumber`

  Vérifie si l'argument est un entier réel positif. Notez que par convention 0 n'est pas un nombre naturel.

IsRational

      IsRational (nbre)

  Vérifie si l'argument est un nombre rationnel (non complexe). Bien sûr, rationnel signifie simplement « non enregistré comme un nombre à virgule flottante ».

IsReal

      IsReal (nbre)

  Vérifie si l'argument est un nombre réel.

Numerator

      Numerator (x)

  Renvoie le numérateur d'un nombre rationnel.

  See Wikipedia for more information.

Re

      Re (z)

  Alias : `RealPart`

  Get the real part of a complex number. For example `Re(3+4i)` yields 3.

  See Wikipedia for more information.

Sign

      Sign (x)

  Alias : `sign`

  Renvoie le signe d'un nombre. C'est-à-dire renvoie `-1` si la valeur est négative, `0` si la valeur est nulle et `1` si la valeur est positive. Si `x` est une grandeur complexe alors `Sign` renvoie la direction ou 0.

ceil

      ceil (x)

  Alias : `Ceiling`

  Get the lowest integer more than or equal to `n`. Examples:

      genius> ceil(1.1)
      = 2
      genius> ceil(-1.1)
      = -1

  Note that you should be careful and notice that floating point numbers are stored in binary and so may not be what you expect. For example `ceil(420/4.2)` returns 101 instead of the expected 100. This is because 4.2 is actually very slightly less than 4.2. Use rational representation `42/10` if you want exact arithmetic.

exp

      exp (x)

  La fonction exponentielle. C'est la fonction `e^x` où `e` est la base du logarithme naturel.

  See Wikipedia or Planetmath or Mathworld for more information.

float

      float (x)

  Transforme le nombre en nombre à virgule flottante. C'est-à-dire la représentation à virgule flottante du nombre `x`.

floor

      floor (x)

  Alias : `Floor`

  Renvoie le plus grand entier inférieur ou égal à `n`.

ln

      ln (x)

  Le logarithme naturel, le logarithme de base `e`.

  See Wikipedia or Planetmath or Mathworld for more information.

log

      log (x)

      log (x,b)

  Logarithm of `x` base `b` (calls `DiscreteLog` if in modulo mode), if base is not given, `e` is used.

log10

      log10 (x)

  Logarithme base 10 de `x`.

log2

      log2 (x)

  Alias : `lg`

  Logarithme base 2 de `x`.

max

      max (a,params...)

  Aliases: `Max` `Maximum`

  Renvoie le maximum des arguments ou de la matrice.

min

      min (a,params...)

  Aliases: `Min` `Minimum`

  Renvoie le minimum des arguments ou de la matrice.

rand

      rand (taille...)

  Génère aléatoirement des nombres flottants dans l'intervalle `[0,1)`. 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é.

randint

      randint (max,taille...)

  Generate random integer in the range `[0,max)`. If size is given then a matrix (if two numbers are specified) or vector (if one number is specified) of the given size returned. For example,

      genius> randint(4)
      = 3
      genius> randint(4,2)
      =
      [0      1]
      genius> randint(4,2,3)
      =
      [2      2       1
       0      0       3]

round

      round (x)

  Alias : `Round`

  Arrondit un nombre.

sqrt

      sqrt (x)

  Alias : `SquareRoot`

  The square root. When operating modulo some integer will return either a `null` or a vector of the square roots. Examples:

      genius> sqrt(2)
      = 1.41421356237
      genius> sqrt(-1)
      = 1i
      genius> sqrt(4) mod 7
      =
      [2      5]
      genius> 2*2 mod 7
      = 4

  See Wikipedia or Planetmath for more information.

trunc

      trunc (x)

  Aliases: `Truncate` `IntegerPart`

  Tronque le nombre à un entier (renvoie la partie entière).

### Trigonométrie

acos

      acos (x)

  Alias : `arccos`

  Fonction arccos (arc cosinus).

acosh

      acosh (x)

  Alias : `arccosh`

  Fonction arccosh (cosinus hyperbolique inverse).

acot

      acot (x)

  Alias : `arccot`

  Fonction arccot (cotangente inverse).

acoth

      acoth (x)

  Alias : `arccoth`

  Fonction arccoth (cotangente hyperbolique inverse).

acsc

      acsc (x)

  Alias : `arccsc`

  Inverse de la fonction cosécante.

acsch

      acsch (x)

  Alias : `arccsch`

  Inverse de la fonction cosécante hyperbolique.

asec

      asec (x)

  Alias : `arcsec`

  Inverse de la fonction sécante.

asech

      asech (x)

  Alias : `arcsech`

  Inverse de la fontion sécante hyperbolique.

asin

      asin (x)

  Alias : `arcsin`

  La fonction arcsin (sinus inverse).

asinh

      asinh (x)

  Alias : `arcsinh`

  Fonction arcsinh (sinus hyperbolique inverse).

atan

      atan (x)

  Alias : `arctan`

  Calcule la fonction arctangente (tangente inverse).

  See Wikipedia or Mathworld for more information.

atanh

      atanh (x)

  Alias : `arctanh`

  Fonction arctanh (tangente hyperbolique inverse).

atan2

      atan2 (y, x)

  Alias : `arctan2`

  Calculates the arctan2 function. If `x>0` then it returns `atan(y/x)`. If `x<0` then it returns `sign(y) * (pi - atan(|y/x|)`. When `x=0` it returns `sign(y) * pi/2`. `atan2(0,0)` returns 0 rather than failing.

  See Wikipedia or Mathworld for more information.

cos

      cos (x)

  Calcule la fonction cosinus.

  See Wikipedia or Planetmath for more information.

cosh

      cosh (x)

  Calcule la fonction cosinus hyperbolique.

  See Wikipedia or Planetmath for more information.

cot

      cot (x)

  Fonction cotangente.

  See Wikipedia or Planetmath for more information.

coth

      coth (x)

  Fonction cotangente hyperbolique.

  See Wikipedia or Planetmath for more information.

csc

      csc (x)

  Fonction cosécante.

  See Wikipedia or Planetmath for more information.

csch

      csch (x)

  Fonction cosécante hyperbolique.

  See Wikipedia or Planetmath for more information.

sec

      sec (x)

  Fonction sécante.

  See Wikipedia or Planetmath for more information.

sech

      sech (x)

  Fonction sécante hyperbolique.

  See Wikipedia or Planetmath for more information.

sin

      sin (x)

  Calcule la fonction sinus.

  See Wikipedia or Planetmath for more information.

sinh

      sinh (x)

  Calcule la fonction sinus hyperbolique.

  See Wikipedia or Planetmath for more information.

tan

      tan (x)

  Calcule la fonction tangente.

  See Wikipedia or Planetmath for more information.

tanh

      tanh (x)

  Fonction tangente hyperbolique.

  See Wikipedia or Planetmath for more information.

### Théorie des nombres

AreRelativelyPrime

      AreRelativelyPrime (a,b)

  Si les entiers `a` et `b` sont premiers entre eux ? Renvoie `true` (vrai) ou `false` (faux).

  See Wikipedia or Planetmath or Mathworld for more information.

BernoulliNumber

      BernoulliNumber (n)

  Renvoie le `n`-ième nombre de Bernoulli.

  See Wikipedia or Mathworld for more information.

ChineseRemainder

      ChineseRemainder (a,m)

  Alias : `CRT`

  Recherche `x` qui résout le système défini par le vecteur `a` et modulo les éléments de `m`, en utilisant le théorème des restes chinois.

  See Wikipedia or Planetmath or Mathworld for more information.

CombineFactorizations

      CombineFactorizations (a,b)

  Étant donné deux factorisations, donne la factorisation du produit.

  Consultez Factorize.

ConvertFromBase

      ConvertFromBase (v,b)

  Convertit un vecteur de valeurs indiquant les puissances de b en un nombre.

ConvertToBase

      ConvertToBase (n,b)

  Convertit un nombre en un vecteur contenant les puissances des éléments dans la base `b`.

DiscreteLog

      DiscreteLog (n,b,q)

  Calcule le logarithme discret de `n` base `b` dans Fq, le corps fini d'ordre `q` où `q` est un nombre premier, en utilisant l'algorithme de Silver-Pohlig-Hellman.

  See Wikipedia, Planetmath, or Mathworld for more information.

Divides

      Divides (m,n)

  Vérifie la divisibilité (si `m` divise `n`).

EulerPhi

      EulerPhi (n)

  Calcule la fonction d'Euler phi, c'est-à-dire le nombre d'entiers compris entre 1 et `n` qui sont premiers avec `n`.

  See Wikipedia, Planetmath, or Mathworld for more information.

ExactDivision

      ExactDivision (n,d)

  Return `n/d` but only if `d` divides `n`. If `d` does not divide `n` then this function returns garbage. This is a lot faster for very large numbers than the operation `n/d`, but it is only useful if you know that the division is exact.

Factorize

      Factorize (n)

  Return factorization of a number as a matrix. The first row is the primes in the factorization (including 1) and the second row are the powers. So for example:

      genius> Factorize(11*11*13)
      =
      [1      11      13
       1      2       1]

  See Wikipedia for more information.

Factors

      Factors (n)

  Return all factors of `n` in a vector. This includes all the non-prime factors as well. It includes 1 and the number itself. So to print all the perfect numbers (those that are sums of their factors) up to the number 1000 you could do (this is clearly very inefficient)

      for n=1 to 1000 do (
          if MatrixSum (Factors(n)) == 2*n then
              print(n)
      )

FermatFactorization

      FermatFactorization (n,tentatives)

  Attempt Fermat factorization of `n` into `(t-s)*(t+s)`, returns `t` and `s` as a vector if possible, `null` otherwise. `tries` specifies the number of tries before giving up.

  C'est une assez bonne factorisation si votre nombre est le produit de deux facteurs très proches l'un de l'autre.

  See Wikipedia for more information.

FindPrimitiveElementMod

      FindPrimitiveElementMod (q)

  Cherche le premier élément primitif dans Fq, le groupe fini d'ordre `q`. Bien sûr, `q` doit être premier.

FindRandomPrimitiveElementMod

      FindRandomPrimitiveElementMod (q)

  Cherche un élément primitif au hasard dans Fq, le groupe fini d'ordre `q` (q doit être premier).

IndexCalculus

      IndexCalculus (n,b,q,S)

  Compute discrete log base `b` of n in Fq, the finite group of order `q` (`q` a prime), using the factor base `S`. `S` should be a column of primes possibly with second column precalculated by `IndexCalculusPrecalculation`.

IndexCalculusPrecalculation

      IndexCalculusPrecalculation (b,q,S)

  Run the precalculation step of `IndexCalculus` for logarithms base `b` in Fq, the finite group of order `q` (`q` a prime), for the factor base `S` (where `S` is a column vector of primes). The logs will be precalculated and returned in the second column.

IsEven

      IsEven (n)

  Teste si un entier est pair.

IsMersennePrimeExponent

      IsMersennePrimeExponent (p)

  Tests if a positive integer `p` is a Mersenne prime exponent. That is if 2p-1 is a prime. It does this by looking it up in a table of known values, which is relatively short. See also MersennePrimeExponents and LucasLehmer.

  See Wikipedia, Planetmath, Mathworld or GIMPS for more information.

IsNthPower

      IsNthPower (m,n)

  Vérifie si un nombre rationnel `m` est une puissance `n`-ième parfaite. Consultez aussi IsPerfectPower et IsPerfectSquare.

IsOdd

      IsOdd (n)

  Teste si un entier est impair.

IsPerfectPower

      IsPerfectPower (n)

  Check an integer for being any perfect power, ab.

IsPerfectSquare

      IsPerfectSquare (n)

  Check an integer for being a perfect square of an integer. The number must be an integer. Negative integers are never perfect squares of integers.

IsPrime

      IsPrime (n)

  Tests primality of integers, for numbers less than 2.5e10 the answer is deterministic (if Riemann hypothesis is true). For numbers larger, the probability of a false positive depends on `IsPrimeMillerRabinReps`. That is the probability of false positive is 1/4 to the power `IsPrimeMillerRabinReps`. The default value of 22 yields a probability of about 5.7e-14.

  If `false` is returned, you can be sure that the number is a composite. If you want to be absolutely sure that you have a prime you can use `MillerRabinTestSure` but it may take a lot longer.

  See Planetmath or Mathworld for more information.

IsPrimitiveMod

      IsPrimitiveMod (g,q)

  Vérifie que `g` est primitif dans Fq, le groupe fini d'ordre `q`, où `q` est premier. Si `q` n'est pas premier, les résultats sont erronés.

IsPrimitiveModWithPrimeFactors

      IsPrimitiveModWithPrimeFactors (g,q,f)

  Vérifie que `g` est primitif dans Fq, le groupe fini d'ordre `q`, où `q` est premier et `f` est un vecteur de facteurs premiers de `q`-1. Si `q` n'est pas premier, les résultats sont erronés.

IsPseudoprime

      IsPseudoprime (n,b)

  If `n` is a pseudoprime base `b` but not a prime, that is if `b^(n-1) == 1 mod n`. This calls the `PseudoprimeTest`

IsStrongPseudoprime

      IsStrongPseudoprime (n,b)

  Teste si `n` est un nombre pseudopremier fort en base `b` mais pas un nombre premier.

Jacobi

      Jacobi (a,b)

  Alias : `JacobiSymbol`

  Calcule le symbole de Jacobi (a/b) (b doit être impair).

JacobiKronecker

      JacobiKronecker (a,b)

  Alias : `JacobiKroneckerSymbol`

  Calcule le symbole de Jacobi (a/b) avec l'extension de Kronecker (a/2)=(2/a) si impair, ou (a/2)=0 si pair.

LeastAbsoluteResidue

      LeastAbsoluteResidue (a,n)

  Renvoie le résidu de `a` modulo `n` avec la plus petite valeur absolue (entre -n/2 et n/2).

Legendre

      Legendre (a,p)

  Alias : `LegendreSymbol`

  Calcule le symbole de Legendre (a/p).

  See Planetmath or Mathworld for more information.

LucasLehmer

      LucasLehmer (p)

  Teste si 2p-1 est un nombre premier de Mersenne en utilisant le test de Lucas-Lehmer. Consultez aussi MersennePrimeExponents et IsMersennePrimeExponent.

  See Wikipedia, Planetmath, or Mathworld for more information.

LucasNumber

      LucasNumber (n)

  Renvoie le `n`-ième nombre de Lucas.

  See Wikipedia, Planetmath, or Mathworld for more information.

MaximalPrimePowerFactors

      MaximalPrimePowerFactors (n)

  Renvoie les puissances premières d'un nombre.

MersennePrimeExponents

      MersennePrimeExponents

  Renvoie un vecteur de nombres premiers de Mersenne qui est une liste d'entiers positifs `p` tels que 2p-1 est entier. Consultez aussi IsMersennePrimeExponent et LucasLehmer.

  See Wikipedia, Planetmath, Mathworld or GIMPS for more information.

MillerRabinTest

      MillerRabinTest (n,reps)

  Use the Miller-Rabin primality test on `n`, `reps` number of times. The probability of false positive is `(1/4)^reps`. It is probably usually better to use `IsPrime` since that is faster and better on smaller integers.

  See Wikipedia or Planetmath or Mathworld for more information.

MillerRabinTestSure

      MillerRabinTestSure (n)

  Use the Miller-Rabin primality test on `n` with enough bases that assuming the Generalized Riemann Hypothesis the result is deterministic.

  See Wikipedia, Planetmath, or Mathworld for more information.

ModInvert

      ModInvert (n,m)

  Renvoie l'inverse de n mod m.

  Consultez Mathworld pour plus d'informations.

MoebiusMu

      MoebiusMu (n)

  Renvoie la fonction mu de Moebius évaluée dans `n`. C'est-à-dire renvoie 0 si `n` n'est pas un produit de nombres premiers différents et `(-1)^k` si c'est un produit de `k` nombres premiers différents.

  See Planetmath or Mathworld for more information.

NextPrime

      NextPrime (n)

  Renvoie le plus petit nombre premier supérieur à `n`. 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 `-NextPrime(-n)`.

  This function uses the GMPs `mpz_nextprime`, which in turn uses the probabilistic Miller-Rabin test (See also `MillerRabinTest`). The probability of false positive is not tunable, but is low enough for all practical purposes.

  See Planetmath or Mathworld for more information.

PadicValuation

      PadicValuation (n,p)

  Renvoie la valuation p-adic (nombre de zéros après la virgule en base `p`).

  See Wikipedia or Planetmath for more information.

PowerMod

      PowerMod (a,b,m)

  Compute `a^b mod m`. The `b`'s power of `a` modulo `m`. It is not necessary to use this function as it is automatically used in modulo mode. Hence `a^b mod m` is just as fast.

Prime

      Prime (n)

  Alias : `prime`

  Renvoie le `n`-ième nombre premier (jusqu'à une limite) .

  See Planetmath or Mathworld for more information.

PrimeFactors

      PrimeFactors (n)

  Renvoie tous les facteurs premiers d'un nombre sous la forme d'un vecteur.

  See Wikipedia or Mathworld for more information.

PseudoprimeTest

      PseudoprimeTest (n,b)

  Pseudoprime test, returns `true` if and only if `b^(n-1) == 1 mod n`

  See Planetmath or Mathworld for more information.

RemoveFactor

      RemoveFactor (n,m)

  Supprime toutes les instances du facteur `m` dans le nombre `n`. C'est-à-dire divise par la plus grande puissance de `m` qui divise `n`.

  See Planetmath or Mathworld for more information.

SilverPohligHellmanWithFactorization

      SilverPohligHellmanWithFactorization (n,b,q,f)

  Calcule le logarithme discret de `n` base `b` dans Fq, le corps fini d'ordre `q` où `q` est un nombre premier, en utilisant l'algorithme de Silver-Pohlig-Hellman, sachant que `f` est la factorisation de `q`-1.

SqrtModPrime

      SqrtModPrime (n,p)

  Cherche la racine carrée de `n` modulo `p` (où `p` est premier). `null` est renvoyé si ce n'est pas un résidu quadratique.

  See Planetmath or Mathworld for more information.

StrongPseudoprimeTest

      StrongPseudoprimeTest (n,b)

  Lance le test de pseudo-primarité forte en base `b` sur `n`.

  See Wikipedia, Planetmath, or Mathworld for more information.

gcd

      gcd (a,params...)

  Alias : `GCD`

  Greatest common divisor of integers. You can enter as many integers as you want in the argument list, or you can give a vector or a matrix of integers. If you give more than one matrix of the same size then GCD is done element by element.

  See Wikipedia, Planetmath, or Mathworld for more information.

lcm

      lcm (a,params...)

  Alias : `LCM`

  Least common multiplier of integers. You can enter as many integers as you want in the argument list, or you can give a vector or a matrix of integers. If you give more than one matrix of the same size then LCM is done element by element.

  See Wikipedia, Planetmath, or Mathworld for more information.

### Manipulation de matrices

AppendElement

      AppendElement (v,elt)

  Append an element to a vector and return the vector. No expansion is done. Normally a row vector is built if starting from `null` or a 1-by-1 matrix, but if given a column vector it will properly build a column vector.

ApplyOverMatrix

      ApplyOverMatrix (a,fonc)

  Applique une fonction sur tous les éléments d'une matrice et renvoie une matrice de résultats.

ApplyOverMatrix2

      ApplyOverMatrix2 (a,b,fonc)

  Applique une fonction sur tous les éléments de 2 matrices (ou 1 valeur et 1 matrice) et renvoie une matrice de résultats.

ColumnsOf

      ColumnsOf (M)

  Extrait les colonnes de la matrice comme un vecteur horizontal.

ComplementSubmatrix

      ComplementSubmatrix (m,r,c)

  Supprime certaines lignes et colonnes d'une matrice.

CompoundMatrix

      CompoundMatrix (k,A)

  Calcule la k-ième matrice composée de A.

CountZeroColumns

      CountZeroColumns (M)

  Count the number of zero columns in a matrix. For example, once you column-reduce a matrix, you can use this to find the nullity. See `cref` and `Nullity`.

DeleteColumn

      DeleteColumn (M,col)

  Supprime une colonne d'une matrice.

DeleteRow

      DeleteRow (M,row)

  Supprime une ligne d'une matrice.

DiagonalOf

      DiagonalOf (M)

  Extrait la diagonale de la matrice comme un vecteur colonne.

  See Wikipedia for more information.

DotProduct

      DotProduct (u,v)

  Get the dot product of two vectors. The vectors must be of the same size. No conjugates are taken so this is a bilinear form even if working over the complex numbers; This is the bilinear scalar product not the sesquilinear scalar product. See HermitianProduct for the standard sesquilinear inner product.

  See Wikipedia or Planetmath for more information.

ExpandMatrix

      ExpandMatrix (M)

  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.

HermitianProduct

      HermitianProduct (u,v)

  Alias : `InnerProduct`

  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é.

  See Wikipedia or Mathworld for more information.

I

      I (n)

  Alias : `eye`

  Renvoie une matrice identité de la taille indiquée, soit une matrice de `n` par `n`. Si `n` vaut zéro, renvoie `null`.

  See Wikipedia or Planetmath for more information.

IndexComplement

      IndexComplement (vec,mtaille)

  Renvoie le complémentaire d'un vecteur d'indices. Le premier indice est toujours 1. Par exemple pour le vecteur `[2,3]` et la taille `5`, cela renvoie `[1,4,5]`. Si `mtaille` vaut 0, cela renvoie toujours `null`.

IsDiagonal

      IsDiagonal (M)

  Indique si la matrice est diagonale.

  See Wikipedia or Planetmath for more information.

IsIdentity

      IsIdentity (x)

  Vérifie qu'une matrice est la matrice identité. Renvoie automatiquement `false` (faux) si la matrice n'est pas carrée. Fonctionne également avec les nombres et dans ce cas, c'est équivalent à `x==1`. Lorsque `x` est `null`, il est considéré comme une matrice 0 par 0, aucune erreur n'est générée et `false` (faux) est renvoyé.

IsLowerTriangular

      IsLowerTriangular (M)

  Indique si une matrice est triangulaire inférieure, c'est-à-dire que toutes les valeurs au dessus de la diagonale sont nulles.

IsMatrixInteger

      IsMatrixInteger (M)

  Check if a matrix is a matrix of integers (non-complex).

IsMatrixNonnegative

      IsMatrixNonnegative (M)

  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.

  See Wikipedia for more information.

IsMatrixPositive

      IsMatrixPositive (M)

  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

  See Wikipedia for more information.

IsMatrixRational

      IsMatrixRational (M)

  Vérifie si une matrice est constituée de nombres rationnels (non complexes).

IsMatrixReal

      IsMatrixReal (M)

  Vérifie si une matrice est constituée de nombres réels (non complexes).

IsMatrixSquare

      IsMatrixSquare (M)

  Vérifie si une matrice est carrée, c'est-à-dire que sa largeur est égale à sa hauteur.

IsUpperTriangular

      IsUpperTriangular (M)

  Is a matrix upper triangular? That is, a matrix is upper triangular if all the entries below the diagonal are zero.

IsValueOnly

      IsValueOnly (M)

  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.

IsVector

      IsVector (v)

  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 `n` ou `n` par 1.

IsZero

      IsZero (x)

  Vérifie si une matrice est composée uniquement de zéros. Fonctionne également avec les nombres et dans ce cas, c'est équivalent à `x==0`. Lorsque `x` est `null`, il est considéré comme une matrice 0 par 0, aucune erreur n'est générée et `true` (vrai) est renvoyé car la condition est vide.

LowerTriangular

      LowerTriangular (M)

  Renvoie une copie de la matrice `M` avec tous les éléments au dessus de la diagonale mis à zéro.

MakeDiagonal

      MakeDiagonal (v,param...)

  Alias : `diag`

  Make diagonal matrix from a vector. Alternatively you can pass in the values to put on the diagonal as arguments. So `MakeDiagonal([1,2,3])` is the same as `MakeDiagonal(1,2,3)`.

  See Wikipedia or Planetmath for more information.

MakeVector

      MakeVector (A)

  Alias: `MakeColumnVector`

  Make column vector out of matrix by putting columns above each other. Returns `null` when given `null`. Can be used to ensure a vector is a column vector.

MakeRowVector

      MakeRowVector (A)

  Make row vector out of matrix by putting rows one after another. Returns `null` when given `null`. Can be used to ensure a vector is a row vector.

MatrixProduct

      MatrixProduct (A)

  Calcule et renvoie le produit de tous les éléments d'une matrice ou d'un vecteur.

MatrixSum

      MatrixSum (A)

  Calcule et renvoie la somme de tous les éléments d'une matrice ou d'un vecteur.

MatrixSumSquares

      MatrixSumSquares (A)

  Calcule la somme du carré de tous les éléments d'une matrice ou d'un vecteur.

NonzeroColumns

      NonzeroColumns (M)

  Returns a row vector of the indices of nonzero columns in the matrix `M`.

  Version 1.0.18 onwards.

NonzeroElements

      NonzeroElements (v)

  Returns a row vector of the indices of nonzero elements in the vector `v`.

  Version 1.0.18 onwards.

OuterProduct

      OuterProduct (u,v)

  Retourne le produit tensoriel de deux vecteurs, c'est-à-dire que si on suppose que `u` et `v` sont des vecteurs colonnes, alors le produit tensoriel est `v * u.'`.

ReverseVector

      ReverseVector (v)

  Inverse l'ordre des éléments d'un vecteur. Renvoie `null` si `null` est fourni

RowSum

      RowSum (m)

  Calcule la somme pour chaque ligne d'une matrice et renvoie un vecteur colonne contenant le résultat.

RowSumSquares

      RowSumSquares (m)

  Calculate sum of squares of each row in a matrix and return a vertical vector with the results.

RowsOf

      RowsOf (M)

  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 `M`. This function is useful if you wish to loop over the rows of a matrix. For example, as `for r in RowsOf(M) do something(r)`.

SetMatrixSize

      SetMatrixSize (M,lignes,colonnes)

  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 `rows` or `columns` are zero then `null` is returned.

ShuffleVector

      ShuffleVector (v)

  Shuffle elements in a vector. Return `null` if given `null`.

  Version 1.0.13 onwards.

SortVector

      SortVector (v)

  Trie les éléments d'un vecteur en ordre croissant.

StripZeroColumns

      StripZeroColumns (M)

  Élimine toutes les colonnes entièrement nulles de `M`.

StripZeroRows

      StripZeroRows (M)

  Élimine toutes les lignes entièrement nulles de `M`.

Submatrix

      Submatrix (m,r,c)

  Renvoie certaines colonnes et lignes d'une matrice. C'est équivalent à `m@(r,c)`. `r` et `c` doivent être des vecteurs de lignes et de colonnes (ou de simples nombres si vous avez besoin d'une seule ligne ou colonne).

SwapRows

      SwapRows (m,ligne1,ligne2)

  Échange deux lignes dans une matrice.

UpperTriangular

      UpperTriangular (M)

  Renvoie une copie de la matrice `M` avec tous les éléments sous la diagonale mis à zéro.

columns

      columns (M)

  Renvoie le nombre de colonnes d'une matrice.

elements

      elements (M)

  Renvoie le nombre total d'éléments d'une matrice. C'est le nombre de colonnes multiplié par le nombre de lignes.

ones

      ones (lignes,colonnes...)

  Crée une matrice de 1 (ou un vecteur colonne si un seul argument est donné). Renvoie `null` si ligne ou colonne est nul.

rows

      rows (M)

  Renvoie le nombre de lignes d'une matrice.

zeros

      zeros (lignes,colonnes...)

  Crée une matrice de 0 (ou un vecteur colonne si un seul argument est donné). Renvoie `null` si ligne ou colonne est nul.

### Algèbre linéaire

AuxiliaryUnitMatrix

      AuxiliaryUnitMatrix (n)

  Get the auxiliary unit matrix of size `n`. 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.

  See Planetmath or Mathworld for more information on Jordan Canonical Form.

BilinearForm

      BilinearForm (v,A,w)

  Évalue (v,w) par rapport à la forme bilinéaire donnée par la matrice A.

BilinearFormFunction

      BilinearFormFunction (A)

  Renvoie une fonction qui évalue deux vecteurs par rapport à la forme bilinéaire donnée par A.

CharacteristicPolynomial

      CharacteristicPolynomial (M)

  Alias : `CharPoly`

  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 `det(M-xI)`. Les racines de ce polynôme sont les valeurs propres de `M`. Consultez également CharacteristicPolynomialFunction.

  See Wikipedia or Planetmath for more information.

CharacteristicPolynomialFunction

      CharacteristicPolynomialFunction (M)

  Renvoie le polynôme caractéristique d'un vecteur sous la forme d'une fonction. Ce polynôme est défini par `det(M-xI)`. Les racines de ce polynôme sont les valeurs propres de `M`. Consultez également CharacteristicPolynomial.

  See Wikipedia or Planetmath for more information.

ColumnSpace

      ColumnSpace (M)

  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 `M`, donc l'espace engendré par les colonnes de `M`.

  See Wikipedia for more information.

CommutationMatrix

      CommutationMatrix (m, n)

  Return the commutation matrix `K(m,n)`, which is the unique `m*n` by `m*n` matrix such that `K(m,n) * MakeVector(A) = MakeVector(A.')` for all `m` by `n` matrices `A`.

CompanionMatrix

      CompanionMatrix (p)

  Matrice compagnon d'un polynôme (comme vecteur).

ConjugateTranspose

      ConjugateTranspose (M)

  Transposée conjuguée d'une matrice (matrice adjointe). Identique à l'opérateur `'`.

  See Wikipedia or Planetmath for more information.

Convolution

      Convolution (a,b)

  Alias : `convol`

  Calcule la convolution de deux vecteurs horizontaux.

ConvolutionVector

      ConvolutionVector (a,b)

  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.

CrossProduct

      CrossProduct (v,w)

  Produit vectoriel de deux vecteurs dans R3 sous la forme d'un vecteur colonne.

  See Wikipedia for more information.

DeterminantalDivisorsInteger

      DeterminantalDivisorsInteger (M)

  Get the determinantal divisors of an integer matrix.

DirectSum

      DirectSum (M,N...)

  Somme directe de matrices.

  See Wikipedia for more information.

DirectSumMatrixVector

      DirectSumMatrixVector (v)

  Somme directe d'un vecteur de matrices.

  See Wikipedia for more information.

Eigenvalues

      Eigenvalues (M)

  Alias : `eig`

  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).

  See Wikipedia, Planetmath, or Mathworld for more information.

Eigenvectors

      Eigenvectors (M)

      Eigenvectors (M, &valeurspropres)

      Eigenvectors (M, &valeurpropres, &multiplicités)

  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.

  See Wikipedia, Planetmath, or Mathworld for more information.

GramSchmidt

      GramSchmidt (v,B...)

  Applique le procédé de Gram-Schmidt (aux colonnes) par rapport au produit scalaire donné par `B`. Si `B` n'est pas fourni alors le produit hermitien standard est utilisé. `B` peut être soit une forme sesquilinéaire à deux arguments soit une matrice fournissant une forme sesquilinéaire. Les vecteurs seront orthogonaux par rapport à `B`.

  See Wikipedia or Planetmath for more information.

HankelMatrix

      HankelMatrix (c,r)

  Hankel matrix, a matrix whose skew-diagonals are constant. `c` is the first row and `r` is the last column. It is assumed that both arguments are vectors and the last element of `c` is the same as the first element of `r`.

  See Wikipedia for more information.

HilbertMatrix

      HilbertMatrix (n)

  Matrice de Hilbert d'ordre `n`.

  See Wikipedia or Planetmath for more information.

Image

      Image (T)

  Renvoie l'image (espace vectoriel engendré par les colonnes) d'une transformation linéaire.

  See Wikipedia for more information.

InfNorm

      InfNorm (v)

  Renvoie la norme « infini », appelée aussi norme sup, ou encore norme de la convergence uniforme.

InvariantFactorsInteger

      InvariantFactorsInteger (M)

  Get the invariant factors of a square integer matrix.

InverseHilbertMatrix

      InverseHilbertMatrix (n)

  Matrice inverse de Hilbert d'ordre `n`.

  See Wikipedia or Planetmath for more information.

IsHermitian

      IsHermitian (M)

  Indique si une matrice est hermitienne. C'est-à-dire si elle est égale à sa transposée conjuguée.

  See Wikipedia or Planetmath for more information.

IsInSubspace

      IsInSubspace (v,W)

  Teste si un vecteur appartient à un sous-espace.

IsInvertible

      IsInvertible (n)

  Is a matrix (or number) invertible (Integer matrix is invertible if and only if it is invertible over the integers).

IsInvertibleField

      IsInvertibleField (n)

  Indique si une matrice (ou un nombre) est inversible sur un corps.

IsNormal

      IsNormal (M)

  Indique si `M` est une matrice normale, c'est-à-dire `M*M' == M'*M`.

  See Planetmath or Mathworld for more information.

IsPositiveDefinite

      IsPositiveDefinite (M)

  Indique si `M` est une matrice hermitienne définie positive. C'est-à-dire si `HermitianProduct(M*v,v)` est toujours strictement positif pour tout vecteur `v`. `M` 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 HermitianProduct).

  Notez que certains auteurs (par exemple Mathworld) n'exigent pas que `M` 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 `M` comme ceci : `IsPositiveDefinite(M+M')`.

  See Wikipedia, Planetmath, or Mathworld for more information.

IsPositiveSemidefinite

      IsPositiveSemidefinite (M)

  Indique si `M` est une matrice hermitienne semi-définie positive. C'est-à-dire si `HermitianProduct(M*v,v)` est toujours non négatif pour tout vecteur `v`. `M` 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 HermitianProduct).

  Notez que certains auteurs n'exigent pas que `M` 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 `M` comme ceci : `IsPositiveSemiDefinite(M+M')`.

  See Planetmath or Mathworld for more information.

IsSkewHermitian

      IsSkewHermitian (M)

  Indique si une matrice est anti-hermitienne. C'est-à-dire si sa transposée conjuguée est égale à l'opposée de la matrice.

  See Planetmath for more information.

IsUnitary

      IsUnitary (M)

  Indique si une matrice est unitaire. C'est-à-dire si `M'*M` et `M*M'` sont égaux à l'identité.

  See Planetmath or Mathworld for more information.

JordanBlock

      JordanBlock (n,lambda)

  Alias : `J`

  Renvoie le bloc de Jordan correspondant à la valeur propre `lambda` de multiplicité `n`.

  See Planetmath or Mathworld for more information.

Kernel

      Kernel (T)

  Renvoie le noyau d'une transformation linéaire.

  (consultez NullSpace)

KroneckerProduct

      KroneckerProduct (M, N)

  Aliases: `TensorProduct`

  Compute the Kronecker product (tensor product in standard basis) of two matrices.

  See Wikipedia, Planetmath or Mathworld for more information.

  Version 1.0.18 onwards.

LUDecomposition

      LUDecomposition (A, L, U)

  Get the LU decomposition of `A`, that is find a lower triangular matrix and upper triangular matrix whose product is `A`. Store the result in the `L` and `U`, which should be references. It returns `true` if successful. For example suppose that A is a square matrix, then after running:

      genius> LUDecomposition(A,&L,&U)

  You will have the lower matrix stored in a variable called `L` and the upper matrix in a variable called `U`.

  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.

  Toutes les matrices ne possèdent pas de décomposition LU, par exemple `[0,1;1,0]` n'en a pas. Dans ce cas, cette fonction renvoie `false` (faux) et initialise `L` et `U` à `null`.

  See Wikipedia, Planetmath or Mathworld for more information.

Minor

      Minor (M,i,j)

  Renvoie le mineur `i`-`j` d'une matrice.

  See Planetmath for more information.

NonPivotColumns

      NonPivotColumns (M)

  Renvoie les colonnes qui ne sont pas les colonnes pivot d'une matrice.

Norm

      Norm (v,p...)

  Alias : `norm`

  Renvoie la norme-p d'un vecteur (ou norme-2 si p n'est pas fourni).

NullSpace

      NullSpace (T)

  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 `T`.

  See Planetmath for more information.

Nullity

      Nullity (M)

  Alias : `nullity`

  Renvoie la dimension du noyau de la matrice `M`.

  See Planetmath for more information.

OrthogonalComplement

      OrthogonalComplement (M)

  Renvoie le complément orthogonal de l'espace des colonnes.

PivotColumns

      PivotColumns (M)

  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.

Projection

      Projection (v,W,B...)

  Projection du vecteur `v` sur le sous-espace `W` par rapport au produit scalaire donné par `B`. Si `B` n'est pas fourni alors le produit hermitien standard est utilisé. `B` peut être soit une forme sesquilinéaire à deux arguments soit une matrice fournissant une forme sesquilinéaire.

QRDecomposition

      QRDecomposition (A, Q)

  Get the QR decomposition of a square matrix `A`, returns the upper triangular matrix `R` and sets `Q` to the orthogonal (unitary) matrix. `Q` should be a reference or `null` if you don't want any return. For example:

      genius> R = QRDecomposition(A,&Q)

  You will have the upper triangular matrix stored in a variable called `R` and the orthogonal (unitary) matrix stored in `Q`.

  See Wikipedia or Planetmath or Mathworld for more information.

RayleighQuotient

      RayleighQuotient (A,x)

  Renvoie le quotient de Rayleigh (aussi appelé le quotient ou rapport de Rayleigh-Ritz) d'une matrice et d'un vecteur.

  See Planetmath for more information.

RayleighQuotientIteration

      RayleighQuotientIteration (A,x,epsilon,maxiter,vecref)

  Cherche les valeurs propres de `A` en utilisant la méthode itérative du quotient de Rayleigh. `x` 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 `maxiter` itérations et renvoie `null` s'il ne peut trouver une solution avec une précision inférieure à `epsilon`. `vecref` doit être soit `null` ou une référence à une variable dans laquelle le vecteur propre est enregistré.

  See Planetmath for more information on Rayleigh quotient.

Rank

      Rank (M)

  Alias : `rank`

  Renvoie le rang d'une matrice.

  See Planetmath for more information.

RosserMatrix

      RosserMatrix ()

  Returns the Rosser matrix, which is a classic symmetric eigenvalue test problem.

Rotation2D

      Rotation2D (angle)

  Alias : `RotationMatrix`

  Renvoie la matrice correspondant à la rotation centrée sur l'origine dans R2.

Rotation3DX

      Rotation3DX (angle)

  Renvoie la matrice correspondant à la rotation centrée sur l'origine dans R3 autour de l'axe des x.

Rotation3DY

      Rotation3DY (angle)

  Renvoie la matrice correspondant à la rotation centrée sur l'origine dans R3 autour de l'axe des y.

Rotation3DZ

      Rotation3DZ (angle)

  Renvoie la matrice correspondant à la rotation centrée sur l'origine dans R3 autour de l'axe des z.

RowSpace

      RowSpace (M)

  Renvoie une matrice de base pour l'espace vectoriel engendré par les lignes d'une matrice.

SesquilinearForm

      SesquilinearForm (v,A,w)

  Évalue (v, w) par rapport à la forme sesquilinéaire donnée par la matrice A.

SesquilinearFormFunction

      SesquilinearFormFunction (A)

  Renvoie une fonction qui évalue deux vecteurs par rapport à la forme sesquilinéaire donnée par A.

SmithNormalFormField

      SmithNormalFormField (A)

  Returns the Smith normal form of a matrix over fields (will end up with 1's on the diagonal).

  See Wikipedia for more information.

SmithNormalFormInteger

      SmithNormalFormInteger (M)

  Return the Smith normal form for square integer matrices over integers.

  See Wikipedia for more information.

SolveLinearSystem

      SolveLinearSystem (M,V,params...)

  Résout le système linéaire Mx=V, renvoie V s'il y a une solution unique ou `null` sinon. Deux références d'arguments supplémentaires peuvent être utilisés pour recevoir les réductions de M et V.

ToeplitzMatrix

      ToeplitzMatrix (c, r...)

  Return the Toeplitz matrix constructed given the first column c and (optionally) the first row r. If only the column c is given then it is conjugated and the nonconjugated version is used for the first row to give a Hermitian matrix (if the first element is real).

  See Wikipedia or Planetmath for more information.

Trace

      Trace (M)

  Alias : `trace`

  Calcule la trace d'une matrice, c'est-à-dire la somme des éléments diagonaux.

  See Wikipedia or Planetmath for more information.

Transpose

      Transpose (M)

  Matrice transposée. C'est identique à l'opérateur `.'`

  See Wikipedia or Planetmath for more information.

VandermondeMatrix

      VandermondeMatrix (v)

  Alias : `vander`

  Renvoie la matrice de Vandermonde.

  See Wikipedia for more information.

VectorAngle

      VectorAngle (v,w,B...)

  L'angle entre deux vecteurs par rapport au produit scalaire donné par `B`. Si `B` n'est pas fourni alors le produit hermitien standard est utilisé. `B` peut être soit une forme sesquilinéaire à deux arguments soit une matrice fournissant une forme sesquilinéaire.

VectorSpaceDirectSum

      VectorSpaceDirectSum (M,N)

  Somme directe des espaces vectoriels M et N.

VectorSubspaceIntersection

      VectorSubspaceIntersection (M,N)

  Intersection des sous-espaces donnés par M et N.

VectorSubspaceSum

      VectorSubspaceSum (M,N)

  Somme des espaces vectoriels M et N, c'est-à-dire {w | w=m+n, m dans M, n dans N}.

adj

      adj (m)

  Alias : `Adjugate`

  Renvoie la matrice adjointe d'une matrice.

cref

      cref (M)

  Aliases: `CREF` `ColumnReducedEchelonForm`

  Calcule la forme échelonnée réduite en colonnes.

det

      det (M)

  Alias : `Determinant`

  Renvoie le déterminant d'une matrice.

  See Wikipedia or Planetmath for more information.

ref

      ref (M)

  Aliases: `REF` `RowEchelonForm`

  Renvoie la matrice échelonnée en lignes (row echelon) d'une matrice. C'est-à-dire effectue une élimination de Gauss de `M`. Les lignes de pivot sont divisées pour que tous les pivots soient égaux à 1.

  See Wikipedia or Planetmath for more information.

rref

      rref (M)

  Aliases: `RREF` `ReducedRowEchelonForm`

  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 `M`.

  See Wikipedia or Planetmath for more information.

### Combinatoire

Catalan

      Catalan (n)

  Renvoie le `n`-ième nombre catalan.

  See Planetmath for more information.

Combinations

      Combinations (k,n)

  Renvoie toutes les combinaisons de k nombres de 1 à n comme un vecteur de vecteurs (consultez aussi NextCombination).

  See Wikipedia for more information.

DoubleFactorial

      DoubleFactorial (n)

  Double factorielle : `n(n-2)(n-4)...`

  See Planetmath for more information.

Factorial

      Factorial (n)

  Factorielle : `n(n-1)(n-2)...`

  See Planetmath for more information.

FallingFactorial

      FallingFactorial (n,k)

  Factorielle décroissante : `(n)_k·=·n(n-1)...(n-(k-1))`

  See Planetmath for more information.

Fibonacci

      Fibonacci (x)

  Alias : `fib`

  Calcule le `n`-ième nombre de Fibonacci. C'est-à-dire le nombre défini de manière récursive par `Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)` et `Fibonacci(1) = Fibonacci(2) = 1`.

  See Wikipedia or Planetmath or Mathworld for more information.

FrobeniusNumber

      FrobeniusNumber (v,param...)

  Calculate the Frobenius number. That is calculate largest number that cannot be given as a non-negative integer linear combination of a given vector of non-negative integers. The vector can be given as separate numbers or a single vector. All the numbers given should have GCD of 1.

  See Wikipedia or Mathworld for more information.

GaloisMatrix

      GaloisMatrix (règle_de_combinaison)

  Galois matrix given a linear combining rule (a_1*x_1+...+a_n*x_n=x_(n+1)).

GreedyAlgorithm

      GreedyAlgorithm (n,v)

  Trouve le vecteur `c` d'entiers non négatifs tel que le produit scalaire par `v` est égal à n. Si ce n'est pas possible, renvoie `null`. `v` doit être fourni trié dans l'ordre croissant et doit être composé d'entier non négatif.

  See Wikipedia or Mathworld for more information.

HarmonicNumber

      HarmonicNumber (n,r)

  Alias : `HarmonicH`

  Harmonic Number, the `n`th harmonic number of order `r`. That is, it is the sum of `1/k^r` for `k` from 1 to n. Equivalent to `sum k = 1 to n do 1/k^r`.

  See Wikipedia for more information.

Hofstadter

      Hofstadter (n)

  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)).

  See Wikipedia for more information. The sequence is A005185 in OEIS.

LinearRecursiveSequence

      LinearRecursiveSequence (valeurs_ensemencement,règle_de_combinaison,n)

  Calcule la relation de récurrence linéaire en utilisant l'algorithme de Galois.

Multinomial

      Multinomial (v,param...)

  Calcule les coefficients multinomiaux. Prend un vecteur de `k` entiers non négatifs et calcule les coefficients multinomiaux. Cela correspond aux coefficients dans le polynôme homogène à `k` variables avec les puissances correspondantes.

  The formula for `Multinomial(a,b,c)` can be written as:

      (a+b+c)! / (a!b!c!)

  In other words, if we would have only two elements, then `Multinomial(a,b)` is the same thing as `Binomial(a+b,a)` or `Binomial(a+b,b)`.

  See Wikipedia, Planetmath, or Mathworld for more information.

NextCombination

      NextCombination (v,n)

  Calcule la combinaison qui apparaîtrait après v dans un appel à la fonction combinations, la première combinaison devrait être `[1:k]`. 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.

  For example with Combinations you would normally write a loop like:

      for n in Combinations (4,6) do (
        SomeFunction (n)
      );

  But with NextCombination you would write something like:

      n:=[1:4];
      do (
        SomeFunction (n)
      ) while not IsNull(n:=NextCombination(n,6));

  See also Combinations.

  See Wikipedia for more information.

Pascal

      Pascal (i)

  Get the Pascal's triangle as a matrix. This will return an `i`+1 by `i`+1 lower diagonal matrix that is the Pascal's triangle after `i` iterations.

  See Planetmath for more information.

Permutations

      Permutations (k,n)

  Renvoie toutes les permutations de `k` nombres de 1 à `n` comme un vecteur de vecteurs.

  See Mathworld or Wikipedia for more information.

RisingFactorial

      RisingFactorial (n,k)

  Alias : `Pochhammer`

  Factorielle croissante (Pochhammer) : (n)_k = n(n+1)...(n+(k-1)).

  See Planetmath for more information.

StirlingNumberFirst

      StirlingNumberFirst (n,m)

  Alias : `StirlingS1`

  Nombre de Stirling du premier type.

  See Planetmath or Mathworld for more information.

StirlingNumberSecond

      StirlingNumberSecond (n,m)

  Alias : `StirlingS2`

  Nombre de Stirling du second type.

  See Planetmath or Mathworld for more information.

Subfactorial

      Subfactorial (n)

  Subfactorial: n! times sum_{k=0}^n (-1)^k/k!.

Triangular

      Triangular (nième)

  Calcule le `n`-ième nombre triangulaire.

  See Planetmath for more information.

nCr

      nCr (n,r)

  Alias : `Binomial`

  Calcule le nombre de combinaisons, c'est-à-dire le coefficient binomial. `n` peut être n'importe quel nombre réel.

  See Planetmath for more information.

nPr

      nPr (n,r)

  Calculate the number of permutations of size `r` of numbers from 1 to `n`.

  See Mathworld or Wikipedia for more information.

### Analyse

CompositeSimpsonsRule

      CompositeSimpsonsRule (f,a,b,n)

  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.

  See Planetmath for more information.

CompositeSimpsonsRuleTolerance

      CompositeSimpsonsRuleTolerance (f,a,b,FourthDerivativeBound,Tolerance)

  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.

  See Planetmath for more information.

Derivative

      Derivative (f,x0)

  Tente de calculer la dérivée en essayant d'abord une approche symbolique puis numérique.

  See Wikipedia for more information.

EvenPeriodicExtension

      EvenPeriodicExtension (f,L)

  Return a function that is the even periodic extension of `f` with half period `L`. That is a function defined on the interval `[0,L]` extended to be even on `[-L,L]` and then extended to be periodic with period `2*L`.

  Consultez aussi OddPeriodicExtension et PeriodicExtension.

  Version 1.0.7 onwards.

FourierSeriesFunction

      FourierSeriesFunction (a,b,L)

  Return a function that is a Fourier series with the coefficients given by the vectors `a` (sines) and `b` (cosines). Note that `a@(1)` is the constant coefficient! That is, `a@(n)` refers to the term `cos(x*(n-1)*pi/L)`, while `b@(n)` refers to the term `sin(x*n*pi/L)`. Either `a` or `b` can be `null`.

  See Wikipedia or Mathworld for more information.

InfiniteProduct

      InfiniteProduct (fonc,début,inc)

  Essaie de calculer un produit infini pour une fonction à un seul argument.

InfiniteProduct2

      InfiniteProduct2 (fonc,param,début,inc)

  Essaie de calculer un produit infini pour une fonction à double arguments avec func(arg,n).

InfiniteSum

      InfiniteSum (fonc,début,inc)

  Essaie de calculer une somme infinie pour une fonction à un seul argument.

InfiniteSum2

      InfiniteSum2 (fonc,param,début,inc)

  Essaie de calculer une somme infinie pour une fonction à double arguments avec func(arg,n).

IsContinuous

      IsContinuous (f,x0)

  Essaie de voir si une fonction à valeur réelle est continue en x0 en calculant la limite en ce point.

IsDifferentiable

      IsDifferentiable (f,x0)

  Teste de différentiabilité en approchant les limites gauche et droite et en les comparant.

LeftLimit

      LeftLimit (f,x0)

  Calcule la limite gauche d'une fonction à valeurs réelles en x0.

Limit

      Limit (f,x0)

  Calcule la limite d'une fonction à valeur réelle en x0. Essaie de calculer les deux limites à gauche et à droite.

MidpointRule

      MidpointRule (f,a,b,n)

  Intégration par la méthode des rectangles.

NumericalDerivative

      NumericalDerivative (f,x0)

  Alias : `NDerivative`

  Essaie de calculer la dérivée par méthode numérique.

  See Wikipedia for more information.

NumericalFourierSeriesCoefficients

      NumericalFourierSeriesCoefficients (f,L,N)

  Return a vector of vectors `[a,b]` where `a` are the cosine coefficients and `b` are the sine coefficients of the Fourier series of `f` with half-period `L` (that is defined on `[-L,L]` and extended periodically) with coefficients up to `N`th harmonic computed numerically. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierSeriesFunction

      NumericalFourierSeriesFunction (f,L,N)

  Return a function that is the Fourier series of `f` with half-period `L` (that is defined on `[-L,L]` and extended periodically) with coefficients up to `N`th harmonic computed numerically. This is the trigonometric real series composed of sines and cosines. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierCosineSeriesCoefficients

      NumericalFourierCosineSeriesCoefficients (f,L,N)

  Return a vector of coefficients of the cosine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the even periodic extension and compute the Fourier series, which only has cosine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`. Note that `a@(1)` is the constant coefficient! That is, `a@(n)` refers to the term `cos(x*(n-1)*pi/L)`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierCosineSeriesFunction

      NumericalFourierCosineSeriesFunction (f,L,N)

  Return a function that is the cosine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the even periodic extension and compute the Fourier series, which only has cosine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierSineSeriesCoefficients

      NumericalFourierSineSeriesCoefficients (f,L,N)

  Return a vector of coefficients of the sine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the odd periodic extension and compute the Fourier series, which only has sine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierSineSeriesFunction

      NumericalFourierSineSeriesFunction (f,L,N)

  Return a function that is the sine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the odd periodic extension and compute the Fourier series, which only has sine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalIntegral

      NumericalIntegral (f,a,b)

  Intégration de f entre a et b, en suivant la règle définie par `NumericalIntegralFunction` et en utilisant les `NumericalIntegralSteps` pas.

NumericalLeftDerivative

      NumericalLeftDerivative (f,x0)

  Essaie de calculer la dérivée à gauche par méthode numérique.

NumericalLimitAtInfinity

      NumericalLimitAtInfinity (_f,step_fun,tolerance,successive_for_success,N)

  Essaie de calculer la limite de f (step_fun(i)) lorsque i va de 1 à N.

NumericalRightDerivative

      NumericalRightDerivative (f,x0)

  Essaie de calculer la dérivée à droite par méthode numérique.

OddPeriodicExtension

      OddPeriodicExtension (f,L)

  Return a function that is the odd periodic extension of `f` with half period `L`. That is a function defined on the interval `[0,L]` extended to be odd on `[-L,L]` and then extended to be periodic with period `2*L`.

  Consultez aussi EvenPeriodicExtension et PeriodicExtension.

  Version 1.0.7 onwards.

OneSidedFivePointFormula

      OneSidedFivePointFormula (f,x0,h)

  Calcule la dérivée d'un côté en utilisant une formule à cinq points.

OneSidedThreePointFormula

      OneSidedThreePointFormula (f,x0,h)

  Calcule la dérivée d'un côté en utilisant une formule à trois points.

PeriodicExtension

      PeriodicExtension (f,a,b)

  Return a function that is the periodic extension of `f` defined on the interval `[a,b]` and has period `b-a`.

  Consultez également OddPeriodicExtension et EvenPeriodicExtension.

  Version 1.0.7 onwards.

RightLimit

      RightLimit (f,x0)

  Calcule la limite à droite d'une fonction à valeurs réelles en x0.

TwoSidedFivePointFormula

      TwoSidedFivePointFormula (f,x0,h)

  Calcule la dérivée des deux côtés en utilisant une formule à cinq points.

TwoSidedThreePointFormula

      TwoSidedThreePointFormula (f,x0,h)

  Calcule la dérivée des deux côtés en utilisant une formule à trois points.

### Fonctions

Argument

      Argument (z)

  Aliases: `Arg` `arg`

  Renvoie l'argument (angle) d'un nombre complexe.

BesselJ0

      BesselJ0 (x)

  Bessel function of the first kind of order 0. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselJ1

      BesselJ1 (x)

  Bessel function of the first kind of order 1. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselJn

      BesselJn (n,x)

  Bessel function of the first kind of order `n`. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselY0

      BesselY0 (x)

  Bessel function of the second kind of order 0. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselY1

      BesselY1 (x)

  Bessel function of the second kind of order 1. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselYn

      BesselYn (n,x)

  Bessel function of the second kind of order `n`. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

DirichletKernel

      DirichletKernel (n,t)

  Dirichlet kernel of order `n`.

DiscreteDelta

      DiscreteDelta (v)

  Renvoie 1 si et seulement si tous les éléments sont nuls.

ErrorFunction

      ErrorFunction (x)

  Alias : `erf`

  Fonction erreur, 2/sqrt(pi) * int_0^x e^(-t^2) dt.

  See Wikipedia or Planetmath for more information.

FejerKernel

      FejerKernel (n,t)

  Noyau Fejer d'ordre `n` évalué en `t`.

  See Planetmath for more information.

GammaFunction

      GammaFunction (x)

  Alias : `Gamma`

  La fonction Gamma. Seules les valeurs réelles sont actuellement implémentées.

  See Planetmath or Wikipedia for more information.

KroneckerDelta

      KroneckerDelta (v)

  Renvoie 1 si et seulement si tous les éléments sont égaux.

LambertW

      LambertW (x)

  The principal branch of Lambert W function computed for only real values greater than or equal to `-1/e`. That is, `LambertW` is the inverse of the expression `x*e^x`. Even for real `x` this expression is not one to one and therefore has two branches over `[-1/e,0)`. See `LambertWm1` for the other real branch.

  See Wikipedia for more information.

  Version 1.0.18 onwards.

LambertWm1

      LambertWm1 (x)

  The minus-one branch of Lambert W function computed for only real values greater than or equal to `-1/e` and less than 0. That is, `LambertWm1` is the second branch of the inverse of `x*e^x`. See `LambertW` for the principal branch.

  See Wikipedia for more information.

MinimizeFunction

      MinimizeFunction (fonc,x,incr)

  Cherche la première valeur pour laquelle f(x)=0.

MoebiusDiskMapping

      MoebiusDiskMapping (a,z)

  Transformation de Möbius du disque vers lui-même en faisant correspondre a à 0.

  See Wikipedia or Planetmath for more information.

MoebiusMapping

      MoebiusMapping (z,z2,z3,z4)

  Transformation de Möbius utilisant le rapport croisé en prenant z2, z3, z4 à 1, 0 et l'infini respectivement.

  See Wikipedia or Planetmath for more information.

MoebiusMappingInftyToInfty

      MoebiusMappingInftyToInfty (z,z2,z3)

  Transformation de Möbius utilisant le rapport croisé en prenant l'infini à l'infini et z2, z3 à 1 et 0 respectivement.

  See Wikipedia or Planetmath for more information.

MoebiusMappingInftyToOne

      MoebiusMappingInftyToOne (z,z3,z4)

  Transformation de Möbius utilisant le rapport croisé en prenant l'infini à 1 et z3, z4 à 0 et l'infini respectivement.

  See Wikipedia or Planetmath for more information.

MoebiusMappingInftyToZero

      MoebiusMappingInftyToZero (z,z2,z4)

  Transformation de Möbius utilisant le rapport croisé en prenant l'infini à 0 et z2, z4 à 1 et l'infini respectivement.

  See Wikipedia or Planetmath for more information.

PoissonKernel

      PoissonKernel (r,sigma)

  Le noyau de Poisson sur D(0,1) (non normalisé à 1, donc son intégrale vaut 2 pi).

PoissonKernelRadius

      PoissonKernelRadius (r,sigma)

  Le noyau de Poisson sur D(0,R) (non normalisé à 1).

RiemannZeta

      RiemannZeta (x)

  Alias : `zeta`

  Fonction zeta de Riemann (seules les valeurs réelles sont actuellement implémentées).

  See Planetmath or Wikipedia for more information.

UnitStep

      UnitStep (x)

  La fonction échelon vaut 0 pour x<0, 1 sinon. C'est l'intégrale de la fonction delta de Dirac. Elle est aussi appelée fonction d'Heaviside.

  See Wikipedia for more information.

cis

      cis (x)

  La fonction `cis` est la même que `cos(x)+1i*sin(x)`.

deg2rad

      deg2rad (x)

  Convertit les degrés en radians.

rad2deg

      rad2deg (x)

  Convertit les radians en degrés.

sinc

      sinc (x)

  Calculates the unnormalized sinc function, that is `sin(x)/x`. If you want the normalized function call `sinc(pi*x)`.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

### Résolution d'équations

CubicFormula

      CubicFormula (p)

  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 `4*x^3 + 2*x + 1` correspond au vecteur `[1,2,0,4]`. 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.

  See Planetmath, Mathworld, or Wikipedia for more information.

EulersMethod

      EulersMethod (f,x0,y0,x1,n)

  Use classical Euler's method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns `y` at `x1`. Unless you explicitly want to use Euler's method, you should really think about using RungeKutta for solving ODE.

  Les systèmes peuvent être résolus en ayant uniquement `y` sous la forme d'un vecteur (colonne) partout. C'est-à-dire `y0` peut être un vecteur et dans ce cas `f` doit prendre un nombre `x` et un vecteur de la même taille comme deuxième argument et doit renvoyer un vecteur de la même taille.

  See Mathworld or Wikipedia for more information.

EulersMethodFull

      EulersMethodFull (f,x0,y0,x1,n)

  Use classical Euler's method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns an `n+1` by 2 matrix with the `x` and `y` values. Unless you explicitly want to use Euler's method, you should really think about using RungeKuttaFull for solving ODE. Suitable for plugging into LinePlotDrawLine or LinePlotDrawPoints.

  Example:

      genius> LinePlotClear();
      genius> line = EulersMethodFull(`(x,y)=y,0,1.0,3.0,50);
      genius> LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");

  Les systèmes peuvent être résolus en ayant uniquement `y` sous la forme d'un vecteur (colonne) partout. C'est-à-dire `y0` peut être un vecteur et dans ce cas `f` doit prendre un nombre `x` et un vecteur de la même taille comme deuxième argument et doit renvoyer un vecteur de la même taille.

  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 ExpandMatrix, and pick out the right columns. Example:

      genius> LinePlotClear();
      genius> lines = EulersMethodFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,500);
      genius> lines = ExpandMatrix(lines);
      genius> firstline = lines@(,[1,2]);
      genius> secondline = lines@(,[1,3]);
      genius> LinePlotWindow = [0,10,-2,2];
      genius> LinePlotDrawLine(firstline,"color","blue","legend","First");
      genius> LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");

  See Mathworld or Wikipedia for more information.

  Version 1.0.10 onwards.

FindRootBisection

      FindRootBisection (f,a,b,TOL,N)

  Find root of a function using the bisection method. `a` and `b` are the initial guess interval, `f(a)` and `f(b)` should have opposite signs. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

FindRootFalsePosition

      FindRootFalsePosition (f,a,b,TOL,N)

  Find root of a function using the method of false position. `a` and `b` are the initial guess interval, `f(a)` and `f(b)` should have opposite signs. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

FindRootMullersMethod

      FindRootMullersMethod (f,x0,x1,x2,TOL,N)

  Cherche la racine d'une fonction en utilisant la méthode de Muller. `TOL` est la tolérance permise et `N` est la limite du nombre d'itérations réalisées, 0 signifiant pas de limite. La fonction renvoie un vecteur `[succes,valeur,itération]` dans lequel `succes` est un booléen indiquant la réussite, `valeur` est la dernière valeur calculée et `itération` est le nombre d'itérations réalisées.

FindRootSecant

      FindRootSecant (f,a,b,TOL,N)

  Find root of a function using the secant method. `a` and `b` are the initial guess interval, `f(a)` and `f(b)` should have opposite signs. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

HalleysMethod

      HalleysMethod (f,df,ddf,guess,epsilon,maxn)

  Find zeros using Halley's method. `f` is the function, `df` is the derivative of `f`, and `ddf` is the second derivative of `f`. `guess` is the initial guess. The function returns after two successive values are within `epsilon` of each other, or after `maxn` tries, in which case the function returns `null` indicating failure.

  See also `NewtonsMethod` and `SymbolicDerivative`.

  Example to find the square root of 10:

      genius> HalleysMethod(`(x)=x^2-10,`(x)=2*x,`(x)=2,3,10^-10,100)

  See Wikipedia for more information.

  Version 1.0.18 onwards.

NewtonsMethod

      NewtonsMethod (f,df,guess,epsilon,maxn)

  Find zeros using Newton's method. `f` is the function and `df` is the derivative of `f`. `guess` is the initial guess. The function returns after two successive values are within `epsilon` of each other, or after `maxn` tries, in which case the function returns `null` indicating failure.

  See also `NewtonsMethodPoly` and `SymbolicDerivative`.

  Example to find the square root of 10:

      genius> NewtonsMethod(`(x)=x^2-10,`(x)=2*x,3,10^-10,100)

  See Wikipedia for more information.

  Version 1.0.18 onwards.

PolynomialRoots

      PolynomialRoots (p)

  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 `4*x^3 + 2*x + 1` correspond au vecteur `[1,2,0,4]`. Renvoie un vecteur colonne contenant les solutions.

  La fonction appelle QuadraticFormula, CubicFormula et QuarticFormula.

QuadraticFormula

      QuadraticFormula (p)

  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. `3*x^2 + 2*x + 1` correspond au vecteur `[1,2,3]`. Renvoie un vecteur colonne contenant les deux solutions.

  See Planetmath, or Mathworld, or Wikipedia for more information.

QuarticFormula

      QuarticFormula (p)

  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. `5*x^4 + 2*x + 1` correspond au vecteur `[1,2,0,0,5]`. Renvoie un vecteur colonne contenant les quatre solutions.

  See Planetmath, Mathworld, or Wikipedia for more information.

RungeKutta

      RungeKutta (f,x0,y0,x1,n)

  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 `x0`, `y0` allant vers `x1` avec `n` incréments, renvoie `y` en `x1`.

  Les systèmes peuvent être résolus en ayant uniquement `y` sous la forme d'un vecteur (colonne) partout. C'est-à-dire `y0` peut être un vecteur et dans ce cas `f` doit prendre un nombre `x` et un vecteur de la même taille comme deuxième argument et doit renvoyer un vecteur de la même taille.

  See Mathworld or Wikipedia for more information.

RungeKuttaFull

      RungeKuttaFull (f,x0,y0,x1,n)

  Use classical non-adaptive fourth order Runge-Kutta method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns an `n+1` by 2 matrix with the `x` and `y` values. Suitable for plugging into LinePlotDrawLine or LinePlotDrawPoints.

  Example:

      genius> LinePlotClear();
      genius> line = RungeKuttaFull(`(x,y)=y,0,1.0,3.0,50);
      genius> LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");

  Les systèmes peuvent être résolus en ayant uniquement `y` sous la forme d'un vecteur (colonne) partout. C'est-à-dire `y0` peut être un vecteur et dans ce cas `f` doit prendre un nombre `x` et un vecteur de la même taille comme deuxième argument et doit renvoyer un vecteur de la même taille.

  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 ExpandMatrix, and pick out the right columns. Example:

      genius> LinePlotClear();
      genius> lines = RungeKuttaFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,100);
      genius> lines = ExpandMatrix(lines);
      genius> firstline = lines@(,[1,2]);
      genius> secondline = lines@(,[1,3]);
      genius> LinePlotWindow = [0,10,-2,2];
      genius> LinePlotDrawLine(firstline,"color","blue","legend","First");
      genius> LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");

  See Mathworld or Wikipedia for more information.

  Version 1.0.10 onwards.

### Statistiques

Average

      Average (m)

  Aliases: `average` `Mean` `mean`

  Calculate average (the arithmetic mean) of an entire matrix.

  See Wikipedia or Mathworld for more information.

GaussDistribution

      GaussDistribution (x,sigma)

  Intégrale de la fonction de Gauss de 0 à `x` (aire sous la courbe normale).

  See Wikipedia or Mathworld for more information.

GaussFunction

      GaussFunction (x,sigma)

  Fonction distribution de Gauss normalisée (courbe normale).

  See Wikipedia or Mathworld for more information.

Median

      Median (m)

  Alias : `median`

  Calcule la médiane de toute une matrice.

  See Wikipedia or Mathworld for more information.

PopulationStandardDeviation

      PopulationStandardDeviation (m)

  Alias : `stdevp`

  Calcule l'écart type de la population de toute une matrice.

RowAverage

      RowAverage (m)

  Alias : `RowMean`

  Calculate average of each row in a matrix. That is, compute the arithmetic mean.

  See Wikipedia or Mathworld for more information.

RowMedian

      RowMedian (m)

  Calcule la médiane de chaque ligne d'une matrice et renvoie un vecteur colonne.

  See Wikipedia or Mathworld for more information.

RowPopulationStandardDeviation

      RowPopulationStandardDeviation (m)

  Alias : `rowstdevp`

  Calcule l'écart type de la population des lignes d'une matrice et renvoie un vecteur colonne.

RowStandardDeviation

      RowStandardDeviation (m)

  Alias : `rowstdev`

  Calcule l'écart type des lignes d'une matrice et renvoie un vecteur colonne.

StandardDeviation

      StandardDeviation (m)

  Alias : `stdev`

  Calcule l'écart type de toute une matrice.

### Polynômes

AddPoly

      AddPoly (p1,p2)

  Ajoute deux polynômes (vecteurs).

DividePoly

      DividePoly (p,q,&r)

  Divise deux polynômes (en tant que vecteurs) en utilisant la division longue. Renvoie le quotient des deux polynômes. L'argument optionnel `r` est utilisé pour renvoyer le reste. Le reste a un degré plus bas que `q`.

  See Planetmath for more information.

IsPoly

      IsPoly (p)

  Vérifie qu'un vecteur est utilisable en tant que polynôme.

MultiplyPoly

      MultiplyPoly (p1,p2)

  Multiplie deux polynômes (comme vecteurs).

NewtonsMethodPoly

      NewtonsMethodPoly (poly,valeurinitiale,epsilon,maxn)

  Find a root of a polynomial using Newton's method. `poly` is the polynomial as a vector and `guess` is the initial guess. The function returns after two successive values are within `epsilon` of each other, or after `maxn` tries, in which case the function returns `null` indicating failure.

  See also `NewtonsMethod`.

  Example to find the square root of 10:

      genius> NewtonsMethodPoly([-10,0,1],3,10^-10,100)

  See Wikipedia for more information.

Poly2ndDerivative

      Poly2ndDerivative (p)

  Renvoie la dérivée seconde du polynôme (comme vecteur).

PolyDerivative

      PolyDerivative (p)

  Prend la dérivée du polynôme (comme vecteur).

PolyToFunction

      PolyToFunction (p)

  Fabrique une fonction à partir d'un polynôme (comme vecteur).

PolyToString

      PolyToString (p,var...)

  Fabrique une chaîne à partir d'un polynôme (comme vecteur).

SubtractPoly

      SubtractPoly (p1,p2)

  Soustrait deux polynômes (comme vecteur).

TrimPoly

      TrimPoly (p)

  Tronque les zéros d'un polynôme (défini comme vecteur).

### Théorie des ensembles

Intersection

      Intersection (X,Y)

  Renvoie l'intersection, selon la théorie des ensembles, de X et Y (X et Y sont des vecteurs supposés être des ensembles).

IsIn

      IsIn (x,X)

  Renvoie `true` (vrai) si l'élément x fait partie de l'ensemble X (où X est un vecteur supposé être un ensemble).

IsSubset

      IsSubset (X, Y)

  Renvoie `true` (vrai) si X est un sous-ensemble de Y (X et Y sont des vecteurs supposés être des ensembles).

MakeSet

      MakeSet (X)

  Renvoie un vecteur où chaque élément de X n'apparaît qu'une seule fois.

SetMinus

      SetMinus (X,Y)

  Renvoie la différence X-Y selon la théorie des ensembles (X et Y sont des vecteurs supposés être des ensembles).

Union

      Union (X,Y)

  Renvoie l'union, selon la théorie des ensembles, de X et Y (X et Y sont des vecteurs supposés être des ensembles).

### Commutative Algebra

MacaulayBound

      MacaulayBound (c,d)

  For a Hilbert function that is c for degree d, given the Macaulay bound for the Hilbert function of degree d+1 (The c^<d> operator from Green's proof).

  Version 1.0.15 onwards.

MacaulayLowerOperator

      MacaulayLowerOperator (c,d)

  The c_<d> operator from Green's proof of Macaulay's Theorem.

  Version 1.0.15 onwards.

MacaulayRep

      MacaulayRep (c,d)

  Return the dth Macaulay representation of a positive integer c.

  Version 1.0.15 onwards.

### Divers

ASCIIToString

      ASCIIToString (vec)

  Convert a vector of ASCII values to a string. See also `StringToASCII`.

  Example:

      genius> ASCIIToString([97,98,99])
      = "abc"

  See Wikipedia for more information.

AlphabetToString

      AlphabetToString (vec,alphabet)

  Convert a vector of 0-based alphabet values (positions in the alphabet string) to a string. A `null` vector results in an empty string. See also `StringToAlphabet`.

  Examples:

      genius> AlphabetToString([1,2,3,0,0],"abcd")
      = "bcdaa"
      genius> AlphabetToString(null,"abcd")
      = ""

StringToASCII

      StringToASCII (chaîne)

  Convert a string to a (row) vector of ASCII values. See also `ASCIIToString`.

  Example:

      genius> StringToASCII("abc")
      = [97, 98, 99]

  See Wikipedia for more information.

StringToAlphabet

      StringToAlphabet (chaîne,alphabet)

  Convert a string to a (row) vector of 0-based alphabet values (positions in the alphabet string), -1's for unknown letters. An empty string results in a `null`. See also `AlphabetToString`.

  Examples:

      genius> StringToAlphabet("cca","abcd")
      = [2, 2, 0]
      genius> StringToAlphabet("ccag","abcd")
      = [2, 2, 0, -1]

### Calcul symbolique

SymbolicDerivative

      SymbolicDerivative (f)

  Essaie de dériver symboliquement la fonction f, où f est une fonction à une variable.

  Examples:

      genius> SymbolicDerivative(sin)
      = (`(x)=cos(x))
      genius> SymbolicDerivative(`(x)=7*x^2)
      = (`(x)=(7*(2*x)))

  See Wikipedia for more information.

SymbolicDerivativeTry

      SymbolicDerivativeTry (f)

  Essaie de dériver symboliquement la fonction f, où f est une fonction à une variable, renvoie `null` en cas d'échec mais reste silencieux (consultez `SymbolicDerivative`).

  See Wikipedia for more information.

SymbolicNthDerivative

      SymbolicNthDerivative (f,n)

  Essaie de dériver symboliquement une fonction n fois (consultez `SymbolicDerivative`).

  See Wikipedia for more information.

SymbolicNthDerivativeTry

      SymbolicNthDerivativeTry (f,n)

  Essaie de dériver symboliquement une fonction n fois silencieusement et renvoie `null` en cas d'échec (consultez `SymbolicNthDerivative`).

  See Wikipedia for more information.

SymbolicTaylorApproximationFunction

      SymbolicTaylorApproximationFunction (f,x0,n)

  Attempt to construct the Taylor approximation function around x0 to the nth degree. (See `SymbolicDerivative`)

### Tracé de graphiques

ExportPlot

      ExportPlot (file,type)

      ExportPlot (file)

  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".

  Note that files are overwritten without asking.

  On successful export, true is returned. Otherwise error is printed and exception is raised.

  Examples:

      genius> ExportPlot("file.png")
      genius> ExportPlot("/directory/file","eps")

  Version 1.0.16 onwards.

LinePlot

      LinePlot (fonc1,fonc2,fonc3,...)

      LinePlot (func1,func2,func3,x1,x2)

      LinePlot (fonc1,fonc2,fonc3,x1,x2,y1,y2)

      LinePlot (func1,func2,func3,[x1,x2])

      LinePlot (func1,func2,func3,[x1,x2,y1,y2])

  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 `x1`, `x2`, `y1`, `y2`. If limits are not specified, then the currently set limits apply (See `LinePlotWindow`) If the y limits are not specified, then the functions are computed and then the maxima and minima are used.

  Le paramètre `LinePlotDrawLegends` conditionne l'affichage de la légende.

  Examples:

      genius> LinePlot(sin,cos)
      genius> LinePlot(`(x)=x^2,-1,1,0,1)

LinePlotClear

      LinePlotClear ()

  Affiche la fenêtre d'affichage du tracé et efface les courbes déjà tracées.

LinePlotCParametric

      LinePlotCParametric (fonc,...)

      LinePlotCParametric (fonc,t1,t2,tinc)

      LinePlotCParametric (fonc,t1,t2,tinc,x1,x2,y1,y2)

  Trace la courbe d'une fonction paramétrique à valeurs complexes. En premier vient la fonction qui renvoie `x+iy` puis, en option, les limites de `t` sous la forme `t1,t2,tinc` puis, en option, les limites de la fenêtre de tracé sous la forme `x1,x2,y1,y2`.

  If limits are not specified, then the currently set limits apply (See `LinePlotWindow`). If instead the string "fit" is given for the x and y limits, then the limits are the maximum extent of the graph

  Le paramètre `LinePlotDrawLegends` conditionne l'affichage de la légende.

LinePlotDrawLine

      LinePlotDrawLine (x1,y1,x2,y2,...)

      LinePlotDrawLine (v,...)

  Draw a line from `x1`,`y1` to `x2`,`y2`. `x1`,`y1`, `x2`,`y2` can be replaced by an `n` by 2 matrix for a longer polyline. Alternatively the vector `v` may be a column vector of complex numbers, that is an `n` by 1 matrix and each complex number is then considered a point in the plane.

  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 `"color"`, `"thickness"`, `"window"`, `"arrow"`, or `"legend"`, 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.)

  If the line is to be treated as a filled polygon, filled with the given color, you can specify the argument `"filled"`. Since version 1.0.22 onwards.

  The color should be either a string indicating the common English word for the color that GTK will recognize such as `"red"`, `"blue"`, `"yellow"`, etc... Alternatively the color can be specified in RGB format as `"#rgb"`, `"#rrggbb"`, or `"#rrrrggggbbbb"`, 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. `[1.0,0.5,0.1]`.

  The window should be given as usual as `[x1,x2,y1,y2]`, or alternatively can be given as a string `"fit"` in which case, the x range will be set precisely and the y range will be set with five percent borders around the line.

  Arrow specification should be `"origin"`, `"end"`, `"both"`, or `"none"`.

  Finally, legend should be a string that can be used as the legend in the graph. That is, if legends are being printed.

  Examples:

      genius> LinePlotDrawLine(0,0,1,1,"color","blue","thickness",3)
      genius> LinePlotDrawLine([0,0;1,-1;-1,-1])
      genius> LinePlotDrawLine([0,0;1,1],"arrow","end")
      genius> LinePlotDrawLine(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")
      genius> 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])
      genius> LinePlotDrawLine([0,0;10,0;10,10;0,10],"filled","color","green")

  Unlike many other functions that do not care if they take a column or a row vector, if specifying points as a vector of complex values, due to possible ambiguities, it must always be given as a column vector.

  Specifying `v` as a column vector of complex numbers is implemented from version 1.0.22 and onwards.

LinePlotDrawPoints

      LinePlotDrawPoints (x,y,...)

      LinePlotDrawPoints (v,...)

  Draw a point at `x`,`y`. The input can be an `n` by 2 matrix for `n` different points. This function has essentially the same input as LinePlotDrawLine. Alternatively the vector `v` may be a column vector of complex numbers, that is an `n` by 1 matrix and each complex number is then considered a point in the plane.

  Extra parameters can be added to specify color, thickness, the plotting window, or legend. You can do this by adding an argument string `"color"`, `"thickness"`, `"window"`, or `"legend"`, and after it specify the color, the thickness, the window as 4-vector, or the legend.

  The color should be either a string indicating the common English word for the color that GTK will recognize such as `"red"`, `"blue"`, `"yellow"`, etc... Alternatively the color can be specified in RGB format as `"#rgb"`, `"#rrggbb"`, or `"#rrrrggggbbbb"`, 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.

  The window should be given as usual as `[x1,x2,y1,y2]`, or alternatively can be given as a string `"fit"` in which case, the x range will be set precisely and the y range will be set with five percent borders around the line.

  Finally, legend should be a string that can be used as the legend in the graph. That is, if legends are being printed.

  Examples:

      genius> LinePlotDrawPoints(0,0,"color","blue","thickness",3)
      genius> LinePlotDrawPoints([0,0;1,-1;-1,-1])
      genius> LinePlotDrawPoints(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")
      genius> LinePlotDrawPoints([1;1+1i;1i;0],"thickness",5)
      genius> LinePlotDrawPoints(ApplyOverMatrix((0:6)',`(k)=exp(k*2*pi*1i/7)),"thickness",3,"legend","The 7th roots of unity")

  Unlike many other functions that do not care if they take a column or a row vector, if specifying points as a vector of complex values, due to possible ambiguities, it must always be given as a column vector. Therefore, notice in the last example the transpose of the vector `0:6` to make it into a column vector.

  Available from version 1.0.18 onwards. Specifying `v` as a column vector of complex numbers is implemented from version 1.0.22 and onwards.

LinePlotMouseLocation

      LinePlotMouseLocation ()

  Returns a row vector of a point on the line plot corresponding to the current mouse location. If the line plot is not visible, then prints an error and returns `null`. In this case you should run `LinePlot` or `LinePlotClear` to put the graphing window into the line plot mode. See also `LinePlotWaitForClick`.

LinePlotParametric

      LinePlotParametric (xfonc,yfonc,...)

      LinePlotParametric (xfonc,yfonc,t1,t2,tinc)

      LinePlotParametric (xfonc,yfonc,t1,t2,tinc,x1,x2,y1,y2)

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc,[x1,x2,y1,y2])

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc,"fit")

  Trace la courbe d'une fonction paramétrique. En premier viennent les fonctions de `x` et `y` puis, en option, les limites de `t` sous la forme `t1,t2,tinc` puis, en option, les limites de la fenêtre de tracé sous la forme `x1,x2,y1,y2`.

  If x and y limits are not specified, then the currently set limits apply (See `LinePlotWindow`). If instead the string "fit" is given for the x and y limits, then the limits are the maximum extent of the graph

  Le paramètre `LinePlotDrawLegends` conditionne l'affichage de la légende.

LinePlotWaitForClick

      LinePlotWaitForClick ()

  If in line plot mode, waits for a click on the line plot window and returns the location of the click as a row vector. If the window is closed the function returns immediately with `null`. If the window is not in line plot mode, it is put in it and shown if not shown. See also `LinePlotMouseLocation`.

PlotCanvasFreeze

      PlotCanvasFreeze ()

  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 `PlotCanvasThaw`.

  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.

  Version 1.0.18 onwards.

PlotCanvasThaw

      PlotCanvasThaw ()

  Thaw the plot canvas frozen by `PlotCanvasFreeze` and redraw the canvas immediately. The canvas is also always thawed after end of execution of any program.

  Version 1.0.18 onwards.

PlotWindowPresent

      PlotWindowPresent ()

  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 is hidden behind the console or other windows.

  Version 1.0.19 onwards.

SlopefieldClearSolutions

      SlopefieldClearSolutions ()

  Efface les solutions tracées par la fonction `SlopefieldDrawSolution`.

SlopefieldDrawSolution

      SlopefieldDrawSolution (x, y, dx)

  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 `dx`. 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 `SlopefieldClearSolutions`. Vous pouvez aussi utiliser l'interface graphique pour tracer des solutions et indiquer des conditions initiales spécifiques avec la souris.

SlopefieldPlot

      SlopefieldPlot (fonc)

      SlopefieldPlot (fonc,x1,x2,y1,y2)

  Trace un champ de directions. La fonction `fonc` doit accepter deux nombres réels `x` et `y` ou seulement un nombre complexe. En option, vous pouvez indiquer les limites de la fenêtre de tracé comme `x1`, `x2`, `y1`, `y2`. Si les limites ne sont pas indiquées alors les limites actuellement utilisées s'appliquent (consultez `LinePlotWindow`).

  Le paramètre `LinePlotDrawLegends` conditionne l'affichage de la légende.

  Examples:

      genius> SlopefieldPlot(`(x,y)=sin(x-y),-5,5,-5,5)

SurfacePlot

      SurfacePlot (fonc)

      SurfacePlot (fonc,x1,x2,y1,y2,z1,z2)

      SurfacePlot (func,x1,x2,y1,y2)

      SurfacePlot (func,[x1,x2,y1,y2,z1,z2])

      SurfacePlot (func,[x1,x2,y1,y2])

  Plot a surface function that takes either two arguments or a complex number. First comes the function then optionally limits as `x1`, `x2`, `y1`, `y2`, `z1`, `z2`. If limits are not specified, then the currently set limits apply (See `SurfacePlotWindow`). Genius can only plot a single surface function at this time.

  If the z limits are not specified then the maxima and minima of the function are used.

  Examples:

      genius> SurfacePlot(|sin|,-1,1,-1,1,0,1.5)
      genius> SurfacePlot(`(x,y)=x^2+y,-1,1,-1,1,-2,2)
      genius> SurfacePlot(`(z)=|z|^2,-1,1,-1,1,0,2)

SurfacePlotClear

      SurfacePlotClear ()

  Show the surface plot window and clear out functions and any other lines that were drawn.

  Available in version 1.0.19 and onwards.

SurfacePlotData

      SurfacePlotData (data)

      SurfacePlotData (data,label)

      SurfacePlotData (data,x1,x2,y1,y2,z1,z2)

      SurfacePlotData (data,label,x1,x2,y1,y2,z1,z2)

      SurfacePlotData (data,[x1,x2,y1,y2,z1,z2])

      SurfacePlotData (data,label,[x1,x2,y1,y2,z1,z2])

  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.

  Optionally we can give the label and also optionally the limits. If limits are not given, they are computed from the data, `SurfacePlotWindow` is not used, if you want to use it, pass it in explicitly. If label is not given then empty label is used.

  Examples:

      genius> SurfacePlotData([0,0,0;1,0,1;0,1,1;1,1,3])
      genius> SurfacePlotData(data,"My data")
      genius> SurfacePlotData(data,-1,1,-1,1,0,10)
      genius> SurfacePlotData(data,SurfacePlotWindow)

  Here's an example of how to plot in polar coordinates, in particular how to plot the function `-r^2 * theta`:

      genius> 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]];
      genius> SurfacePlotData(d)

  Version 1.0.16 onwards.

SurfacePlotDataGrid

      SurfacePlotDataGrid (data,[x1,x2,y1,y2])

      SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2])

      SurfacePlotDataGrid (data,[x1,x2,y1,y2],label)

      SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2],label)

  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 `x1` and `x2` give the interval on the x-axis that we use, and the limits `y1` and `y2` give the interval on the y-axis that we use. If the limits `z1` and `z2` are not given they are computed from the data (to be the extreme values from the data).

  Optionally we can give the label, if label is not given then empty label is used.

  Examples:

      genius> SurfacePlotDataGrid([1,2;3,4],[0,1,0,1])
      genius> SurfacePlotDataGrid(data,[-1,1,-1,1],"My data")
      genius> d:=null; for i=1 to 20 do for j=1 to 10 do d@(i,j) = (0.1*i-1)^2-(0.1*j)^2;
      genius> SurfacePlotDataGrid(d,[-1,1,0,1],"half a saddle")

  Version 1.0.16 onwards.

SurfacePlotDrawLine

      SurfacePlotDrawLine (x1,y1,z1,x2,y2,z2,...)

      SurfacePlotDrawLine (v,...)

  Draw a line from `x1`,`y1`,`z1` to `x2`,`y2`,`z2`. `x1`,`y1`,`z1`, `x2`,`y2`,`z2` can be replaced by an `n` by 3 matrix for a longer polyline.

  Extra parameters can be added to specify line color, thickness, the plotting window, or legend. You can do this by adding an argument string `"color"`, `"thickness"`, `"window"`, or `"legend"`, and after it specify the color, the thickness, the window as 6-vector, or the legend.

  The color should be either a string indicating the common English word for the color that GTK will recognize such as `"red"`, `"blue"`, `"yellow"`, etc... Alternatively the color can be specified in RGB format as `"#rgb"`, `"#rrggbb"`, or `"#rrrrggggbbbb"`, 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. `[1.0,0.5,0.1]`.

  The window should be given as usual as `[x1,x2,y1,y2,z1,z2]`, or alternatively can be given as a string `"fit"` in which case, the x range will be set precisely and the y range will be set with five percent borders around the line.

  Finally, legend should be a string that can be used as the legend in the graph. That is, if legends are being printed.

  Examples:

      genius> SurfacePlotDrawLine(0,0,0,1,1,1,"color","blue","thickness",3)
      genius> SurfacePlotDrawLine([0,0,0;1,-1,2;-1,-1,-3])

  Available from version 1.0.19 onwards.

SurfacePlotDrawPoints

      SurfacePlotDrawPoints (x,y,z,...)

      SurfacePlotDrawPoints (v,...)

  Draw a point at `x`,`y`,`z`. The input can be an `n` by 3 matrix for `n` different points. This function has essentially the same input as SurfacePlotDrawLine.

  Extra parameters can be added to specify line color, thickness, the plotting window, or legend. You can do this by adding an argument string `"color"`, `"thickness"`, `"window"`, or `"legend"`, and after it specify the color, the thickness, the window as 6-vector, or the legend.

  The color should be either a string indicating the common English word for the color that GTK will recognize such as `"red"`, `"blue"`, `"yellow"`, etc... Alternatively the color can be specified in RGB format as `"#rgb"`, `"#rrggbb"`, or `"#rrrrggggbbbb"`, 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.

  The window should be given as usual as `[x1,x2,y1,y2,z1,z2]`, or alternatively can be given as a string `"fit"` in which case, the x range will be set precisely and the y range will be set with five percent borders around the line.

  Finally, legend should be a string that can be used as the legend in the graph. That is, if legends are being printed.

  Examples:

      genius> SurfacePlotDrawPoints(0,0,0,"color","blue","thickness",3)
      genius> SurfacePlotDrawPoints([0,0,0;1,-1,2;-1,-1,1])

  Available from version 1.0.19 onwards.

VectorfieldClearSolutions

      VectorfieldClearSolutions ()

  Efface les solutions dessinées par la fonction `VectorfieldDrawSolution`.

  Version 1.0.6 onwards.

VectorfieldDrawSolution

      VectorfieldDrawSolution (x, y, dt, tlong)

  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 `dt` sur un intervalle de temps `tlong`. 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 `VectorfieldClearSolutions`. Vous pouvez aussi utiliser l'interface graphique pour tracer des solutions et indiquer des conditions initiales spécifiques avec la souris.

  Version 1.0.6 onwards.

VectorfieldPlot

      VectorfieldPlot (foncx, foncy)

      VectorfieldPlot (foncx, foncy, x1, x2, y1, y2)

  Trace un champ de vecteurs à deux dimensions. La fonction `funcx` doit être la dérivée dx/dt du champ de vecteurs et la fonction `funcy` la dérivée dy/dt du champ de vecteurs. Les fonctions doivent accepter deux nombres réels `x` et `y` ou seulement un nombre complexe. Lorsque le paramètre `VectorfieldNormalized` est `true` (vrai) alors l'amplitude des vecteurs est normalisée. Seule la direction et non pas l'amplitude est tracée.

  Vous pouvez spécifier, en option, les limites de la fenêtre de tracé sous la forme `x1`, `x2`, `y1`, `y2`, `z1`, `z2`. Si les limites ne sont pas indiquées alors les limites actuellement utilisées s'appliquent (consultez `LinePlotWindow`).

  Le paramètre `LinePlotDrawLegends` conditionne l'affichage de la légende.

  Examples:

      genius> VectorfieldPlot(`(x,y)=x^2-y, `(x,y)=y^2-x, -1, 1, -1, 1)

## Exemple de programmes en GEL

Here is a function that calculates factorials:

    function f(x) = if x <= 1 then 1 else (f(x-1)*x)

With indentation it becomes:

    function f(x) = (
      if x <= 1 then
        1
      else
        (f(x-1)*x)
    )

This is a direct port of the factorial function from the bc manpage. The syntax seems similar to bc, but different in that in GEL, the last expression is the one that is returned. Using the `return` function instead, it would be:

    function f(x) = (
      if (x <= 1) then return (1);
      return (f(x-1) * x)
    )

By far the easiest way to define a factorial function would be using the product loop as follows. This is not only the shortest and fastest, but also probably the most readable version.

    function f(x) = prod k=1 to x do k

Here is a larger example, this basically redefines the internal `ref` function to calculate the row echelon form of a matrix. The function `ref` is built in and much faster, but this example demonstrates some of the more complex features of GEL.

    # 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
    )

## Paramètres

To configure Genius Mathematics Tool, choose Settings Preferences. There are several basic parameters provided by the calculator in addition to the ones provided by the standard library. These control how the calculator behaves.

### Modifications des paramètres avec GEL

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 à propos de l'évaluation et pour une liste des réglages qui peuvent être modifiés de cette façon.

As an example, you can set the maximum number of digits in a result to 12 by typing:

    MaxDigits = 12

### Sortie

Maximum digits to output

  The maximum digits in a result (`MaxDigits`)

Results as floats

  If the results should be always printed as floats (`ResultsAsFloats`)

Floats in scientific notation

  If floats should be in scientific notation (`ScientificNotation`)

Always print full expressions

  Should we print out full expressions for non-numeric return values (longer than a line) (`FullExpressions`)

Use mixed fractions

  If fractions should be printed as mixed fractions such as "1 1/3" rather than "4/3". (`MixedFractions`)

Display 0.0 when floating point number is less than 10^-x (0=never chop)

  How to chop output. But only when other numbers nearby are large. See the documentation of the parameter `OutputChopExponent`.

Only chop numbers when another number is greater than 10^-x

  When to chop output. This is set by the parameter `OutputChopWhenExponent`. See the documentation of the parameter `OutputChopExponent`.

Remember output settings across sessions

  Si les réglages concernant la sortie dans le cadre Options pour la sortie des nombres/expressions doivent être conservés pour la session suivante. Ne s'applique pas au cadre Options pour la sortie erreurs/information.

  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.

Display errors in a dialog

  If set the errors will be displayed in a separate dialog, if unset the errors will be printed on the console.

Display information messages in a dialog

  If set the information messages will be displayed in a separate dialog, if unset the information messages will be printed on the console.

Maximum errors to display

  The maximum number of errors to return on one evaluation (`MaxErrors`). 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.

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 .

`IntegerOutputBase`

  La base utilisée pour afficher les entiers.

`OutputStyle`

  A string, can be `"normal"`, `"latex"`, `"mathml"` or `"troff"` 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 Genius Mathematics Tool. The other styles are for typesetting in LaTeX, MathML (XML), or in Troff.

### Précision

Floating point precision

  The floating point precision in bits (`FloatPrecision`). 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 `pi` or `e`.

Remember precision setting across sessions

  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.

### Terminal

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

Scrollback lines

  Nombre de lignes d'historique dans le terminal.

Font

  La police à utiliser dans le terminal.

Black on white

  Si vous utilisez du noir sur blanc dans le terminal.

Blinking cursor

  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.

### Mémoire

Maximum number of nodes to allocate

  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.

  Une fois que la limite est atteinte, l'Outil de maths Genius 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.

  Régler la limite à zéro signifie qu'il n'y a aucune limite sur la quantité de mémoire utilisable par Genius.

## À propos de l'Outil de maths Genius

L'Outil de maths Genius a été écrit par Jiří (George) Lebl (jirka@5z.com). L'historique de l'Outil de maths Genius 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'Outil de maths Genius, visitez la page Web de Genius.

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).

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 link, or in the file COPYING included with the source code of this program.

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.