# Manuel de Genius

## Introduction

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

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

Ce manuel décrit principalement la version graphique du calculateur mais bien sûr le langage de programmation est le même. Il ne manque à la version en ligne de commande que les possibilités graphiques et toutes les autres fonctionnalités qui requièrent l'interface graphique.

## Premiers pas

### Lancement de l'Outil de maths Genius

Vous pouvez démarrer l'Outil de maths Genius d'une des manières suivantes :

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 mainwindow-fig apparaît.

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

Affiche Outil de maths Genius la fenêtre principale. Contient la barre de titre, la barre de menus, la barre d'outils et la zone de travail. La barre de menu contient Fichier, Édition, Calculatrice, Paramètres et Aide.

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

  Le menu Calculateur contrôle le moteur de calcul. Il vous permet de lancer le programme actuellement sélectionné ou d'interrompre le calcul en cours. Vous pouvez également afficher l'expression complète de la dernière réponse (c'est utile si la dernière expression est trop grande pour tenir sur la console) ou afficher une liste des valeurs de toutes les variables définies par l'utilisateur. Enfin, il permet de tracer des fonctions en utilisant une boîte de dialogue conviviale.

  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.

  La zone de travail ne contient initialement que l'onglet Console qui est la principale façon d'interagir avec le calculateur. Vous pouvez saisir ici des expressions et les résultats sont immédiatement affichés après avoir appuyé sur la touche Entrée.

  Vous pouvez également écrire des programmes plus longs qui peuvent apparaître dans des onglets séparés et peuvent être enregistrés dans des fichiers pour pouvoir les reprendre plus tard.

## Utilisation de base

### Utilisation de la zone de travail

Normalement, vous interagissez avec le calculateur dans l'onglet Console de la zone de travail. Si vous n'utilisez que la version texte de l'application alors la console est la seule chose disponible. Si vous voulez utiliser l'Outil de maths Genius en tant que calculatrice seulement, saisissez vos expressions ici et elles seront évaluées.

Saisissez vos expressions dans la zone de travail Console, appuyez sur la touche Entrée et l'expression est évaluée. Les expressions sont écrites dans un langage appelé GEL. L'expression GEL la plus simple ressemble à des mathématiques. Par exemple

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

ou

    genius> 62734 + 812634 + 77^4 mod 5

ou

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

ou

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

(cette dernière est une série harmonique de 1 à 70).

Pour obtenir une liste des fonctions et commandes, saisissez :

    genius> help

Si vous souhaitez obtenir plus d'aide sur une fonction précise, saisissez :

    genius> help NomDeLaFonction

Pour afficher ce manuel, saisissez :

    genius> manual

Supposons que vous ayez auparavant enregistré un programme contenant des commandes GEL dans un fichier et que vous vouliez maintenant les exécuter. Pour charger ce programme à partir du fichier `chemin/vers/programme.gel`, saisissez

    genius> load chemin/vers/programme.gel

L'Outil de maths Genius garde la trace du répertoire actuel. Pour afficher la liste des fichiers dans le répertoire actuel, saisissez `ls`, pour changer de répertoire, saisissez `cd répertoire` comme dans un shell de commande unix.

### Création d'un programme

Pour commencer à écrire un nouveau programme, choisissez Fichier Nouveau programme. Un nouvel onglet apparaît dans la zone de travail. Vous pouvez écrire un programme GEL dans cet espace de travail. Après avoir écrit votre programme, vous pouvez l'exécuter à l'aide de la commande Calculateur Exécuter. Cela lance votre programme et affiche toutes les sorties dans l'onglet Console. Exécuter un programme est équivalent à prendre le texte du programme et à le saisir dans la console. La seule différence est que cette entrée est faite indépendamment de la console et que seule la sortie apparaît dans la console. Calculateur Exécuter exécute toujours le programme actuellement sélectionné, même si vous êtes dans l'onglet Console. Le programme actuellement sélectionné est celui dont l'onglet est en gras. Pour sélectionner un autre programme, il suffit de cliquer sur son onglet.

Pour enregistrer le programme que vous venez d'écrire, choisissez Fichier Enregistrer sous...

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

## 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 genius-gel pour apprendre comment saisir des expressions compréhensibles par Genius.

### Tracé de lignes

Pour tracer des fonctions réelles d'une variable, ouvrez la fenêtre Création de graphiques. Vous pouvez aussi utiliser la fonction `LinePlot` en ligne de commande (consultez sa documentation).

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

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

Affiche la fenêtre pour tracer des graphiques.

Dans les cases de texte, il suffit de saisir les expressions dans lesquelles `x` est la variable indépendante. Vous pouvez également donner uniquement le nom des fonctions comme `cos` plutôt que de saisir `cos(x)`. Vous pouvez tracer jusqu'à dix fonctions. Si vous faites une erreur et que Genius ne peut pas analyser l'entrée, une icône d'avertissement est affichée à droite de la case de texte qui contient l'erreur et une boîte de dialogue contenant l'erreur s'ouvre. Vous pouvez modifier les plages des variables dépendantes et indépendantes en bas de la boîte de dialogue. Un appui sur le bouton Tracer produit le graphe lineplot2-fig.

#### Fenêtre contenant une courbe

Le graphe produit.

À 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

Dans la fenêtre Création de courbe, vous pouvez également sélectionner l'onglet Courbe paramétrique pour créer des courbes paramétriques à deux dimensions. Vous ne pouvez tracer qu'une seule fonction paramétrique. Vous pouvez indiquer les points soit sous la forme x et y ou bien sous celle d'un seul nombre complexe. Consultez paramplot-fig.

#### Onglet pour les courbes paramétriques

Onglet pour tracer paramétrique dans la fenêtre Création de graphiques.

Un exemple de tracé paramétrique est montré en paramplot-fig. 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 des fonctions `LinePlotParametric` ou `LinePlotCParametric`.

#### Courbe paramétrique

Courbe paramétrique produite

### 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 peut aussi tracer des surfaces. Sélectionnez l'onglet Tracé de surface dans l'onglet principal de la fenêtre de Création de graphiques. Dans celui-ci, vous pouvez indiquer une expression simple qui doit utiliser soit les variables indépendantes `x` et `y` ou la variable complexe `z` (où `x` est la partie réelle de `z` et `y` sa partie imaginaire). Par exemple, pour tracer le module de la fonction cosinus pour des arguments complexes, vous pouvez saisir `|cos(z)|` ce qui est équivalent à `|cos(x+1i*y)|` (consultez surfaceplot-fig). Pour réaliser des graphiques en ligne de commande, consultez la documentation de la fonction `SurfacePlot`.

#### Graphique de surface

Module de la fonction cosinus complex.

## Fondamentaux GEL

GEL signifie Genius Extension Language (langage d'extension de Genius). C'est le langage que vous devez utiliser pour écrire des programmes dans Genius. Un programme en GEL est simplement une expression qui renvoie un nombre. L'Outil de maths Genius peut par conséquent être utilisé comme une simple calculatrice ou comme un puissant outil de recherche théorique. La syntaxe a été pensée pour permettre un apprentissage rapide, en particulier pour utiliser Genius comme une calculatrice.

### Types de données

Les données GEL peuvent être des nombres, des booléens ou des chaînes de caractères. Les données peuvent, entre autre, être utilisées dans des calculs, attribuées à des variables et renvoyées par des fonctions.

#### Nombres

Les entiers sont les premiers types de nombres GEL. Les entiers s'écrivent de façon habituelle.

    1234

Les nombres hexadécimaux et octaux peuvent être écrit à la manière du langage C. Par exemple :

    0x123ABC
    01234

Vous pouvez aussi saisir des nombres dans n'importe quelle base en utilisant la notation `<base>\<nombre>`. Les chiffres plus grands que 10 utilisent des lettres tout comme pour l'hexadécimal. Par exemple, un nombre en base 23 pourrait s'écrire :

    23\1234ABCD

Le deuxième type de nombres en GEL est celui des rationnels. Les rationnels sont simplement obtenus en divisant deux entiers. Il serait donc possible d'écrire :

    3/4

pour obtenir trois quarts. Les rationnels acceptent également la notation fractionnelle mixte, donc afin d'obtenir un et trois dixièmes, vous pouvez écrire :

    1 3/10

Le type suivant est celui des nombres à virgule flottante. Ils sont saisis de la même manière qu'en C. Vous pouvez utiliser `E`, `e` ou `@` pour délimiter l'exposant. Notez que l'utilisation d'un délimiteur d'exposant implique un flottant même s'il n'y a pas de point séparateur des décimales dans le nombre. Exemples :

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

Lorsque Genius affiche un flottant, il ajoute toujours `.0` même si le nombre est entier. C'est pour rappeler que les nombres à virgule flottante sont considérés comme des quantités imprécises. Lorsqu'un nombre est écrit en utilisant la notation scientifique, c'est toujours un flottant et, par conséquent, Genius n'affiche pas le `.0`.

Le dernier type de nombres GEL est celui des nombres complexes. Vous pouvez saisir un nombre complexe sous sa forme cartésienne, ou sous sa forme exponentielle. La partie imaginaire se termine par un `i`. Voici des exemples de saisies de nombres complexes :

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

Vous pouvez également faire des calculs avec des données booléennes. Par exemple :

    ( (1 + true) - false ) * true

est identique à :

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

Seules l'addition, la soustraction et la multiplication sont prises en charge. Si vous mélangez des nombres avec des booléens dans une expression alors les nombres sont convertis en booléens comme indiqué ci-dessus. Cela signifie que, par exemple :

    1 == true

vaut toujours `true` puisque 1 est converti en `true` avant d'être comparé à `true`.

#### Chaînes de caractères

Tout comme les nombres et les booléens, les chaînes en GEL peuvent être enregistrées dans des variables et transmises à des fonctions. Vous pouvez également concaténer une chaîne avec une autre en utilisant l'opérateur plus. Par exemple,

    a=2+3;"Le résultat est : "+a

crée la chaîne :

    Le résultat est : 5

Vous pouvez également utiliser des séquences d'échappement comme `\n`,`\t`,`\b`,`\a` et `\r`. Pour obtenir un `\` ou un `"` dans une chaîne, vous devez les faire précéder d'un `\`. Par exemple :

    "Barre oblique : \\ Guillemets : \" Tabulations : \t1\t2\t3"

produit la chaîne :

    Barre oblique : \ Guillemets : " Tabulations : 	1	2	3

Vous pouvez en plus utiliser la fonction `string` de la bibliothèque pour convertir n'importe quoi en chaîne. Par exemple :

    string(22)

renvoie

    "22"

Les chaînes peuvent être également comparées avec les opérateurs `==` (égal à), `!=` (différent de) et `<=>` (comparaison).

#### Null

Il existe une grandeur spéciale appelée `null`. Il n'est pas possible de faire des calculs avec elle et rien n'est affichée lorsqu'elle est renvoyée. Par conséquent, `null` est utile lorsque vous voulez qu'une expression n'affiche rien. La valeur `null` peut être obtenue lorsque vous saisissez un point « `.` », la constante `null` ou rien. Par rien, nous voulons dire que si vous terminez une expression par un séparateur `;`, c'est équivalent de la terminer par un séparateur suivi d'un `null`.

Exemple :

    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

Syntaxe :

    NomDeVariable

Exemple :

    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 genius-gel-functions-defining).

#### 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

Syntaxe :

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

Exemple:

    x = 3
    x := 3

Pour attribuer une variable, utilisez les opérateurs `=` ou `:=`. Ces opérateurs fixent la valeur de la variable et renvoient le nombre que vous y avez placé donc vous pouvez écrire des choses comme cela :

    a = b = 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.

Pour les problèmes concernant le champ d'application des variables, consultez genius-gel-variables-global.

#### Variables internes

GEL possède un certain nombre de « variables », telles que `e`, `pi` ou `GoldenRatio`. Ce sont des constantes largement utilisées qui possèdent une valeur prédéfinie et il n'est pas possible de leur attribuer de nouvelles valeurs. Il y a un certain nombre d'autres variables intégrées. Consultez genius-gel-function-list-constants pour une liste complète.

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

Les variables `Ans` et `ans` (answer : réponse) peuvent être utilisées pour obtenir le résultat de la dernière expression. Par exemple, si vous avez fait un calcul, pour ajouter 389 au résultat précédent vous pouvez saisir :

    Ans+389

### Utilisation des fonctions

Syntaxe :

    NomDeLaFonction(argument1, argument2, ...)

Exemple :

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

Pour évaluer une fonction, saisissez le nom de la fonction, suivi par les arguments de la fonction (s'il y en a) entre parenthèses. Cela renvoie le résultat de l'application de la fonction avec ses arguments. Le nombre d'arguments de la fonction peut, bien sûr, être différent pour chaque fonction.

Il y a beaucoup de fonctions intégrées, telles que `sin`, `cos` et `tan`. Vous pouvez utiliser la fonction intégrée `help` pour obtenir une liste des fonctions disponibles ou consultez genius-gel-function-list pour un listing complet.

#### 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

Syntaxe :

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

Le caractère accent grave ``` indique une fonction anonyme. En l'apposant à un nom de variable, en réalité vous définissez une fonction.

Une fonction prend zéro argument ou plus, séparés par des virgules et renvoie le résultat du corps de la fonction. Le fait de définir ses propres fonctions est une question de commodité ; un usage possible est d'avoir un ensemble de fonctions définies dans des fichiers GEL que Genius peut charger afin de les rendre accessibles. Exemple :

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

alors `addup(1,4,9)` donne 14.

#### Liste d'arguments variable

Si vous ajoutez `...` après le dernier nom d'argument dans la déclaration de fonction alors Genius permet la transmission d'un nombre quelconque d'arguments à la place de cet argument. Si aucun argument n'est transmis alors cet argument est défini à `null`. Sinon, c'est un vecteur ligne contenant tous les arguments. Par exemple,

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

alors `f(1,2,3)` donne `[2,3]` tandis que `f(1)` donne `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.

Si vous ne saisissez pas les parenthèses après un nom de fonction, la fonction est renvoyée sous la forme d'un « nœud de fonction », au lieu d'être évaluée. Le nœud de fonction peut ensuite être transmis à une autre fonction. Par exemple :

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

Pour transmettre des fonctions qui ne sont pas encore définies, vous pouvez utiliser une fonction anonyme (consultez genius-gel-functions-defining) donc si vous voulez transmettre une fonction sans lui donner de nom, la syntaxe est la suivante :

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

Exemple :

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

renvoie la valeur 5.

#### Opérations sur les fonctions

Certaines fonctions permettent à des opérations arithmétiques et à certaines fonctions à un seul argument telles que `exp` ou `ln` d'agir sur la fonction. Par exemple,

    exp(sin*cos+4)

renvoie une fonction qui prend `x` et renvoie `exp(sin(x)*cos(x)+4)`. C'est fonctionnellement équivalent de saisir

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

Cette opération peut être utile pour définir rapidement des fonctions. Par exemple, pour créer une fonction appelée `f` pour réaliser l'opération ci-dessus, vous pouvez simplement saisir :

    f = exp(sin*cos+4)

Cela peut également être utilisé pour tracer des graphiques. Par exemple, pour tracer sinus au carré, vous pouvez saisir :

    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.

### Valeur absolue / module

Vous pouvez prendre la valeur absolue de quelque chose en l'entourant de `|`. Par exemple :

    |a-b|

Si l'expression est un nombre complexe, le résultat est le module (distance à partir de l'origine). Par exemple : `|3 * e^(1i*pi)|` renvoie 3.

### Séparateur

En GEL, si vous voulez saisir plus d'une commande, vous devez utiliser l'opérateur `;` qui est une façon de séparer des expressions. Une telle expression combinée renvoie le résultat de la dernière expression, donc si vous saisissez ceci :

    3 ; 5

la valeur 5 est renvoyée.

La présence de parenthèses peut parfois être nécessaire pour rendre l'expression non ambiguë, plus particulièrement si le `;` n'est pas la primitive la plus haute. Cela diffère légèrement des autres languages de programmation pour lesquels le `;` indique la fin des instructions alors qu'en GEL, c'est en fait un opérateur binaire. Si vous êtes familier avec le pascal, cela doit être une seconde nature. Genius peut cependant vous faire croire que c'est en quelque sorte un terminateur si un `;` est trouvé à la fin d'une parenthèse ou d'un bloc, genius lui ajoute alors un nœud `null` comme si vous aviez saisi `;null`. C'est utile au cas où vous ne vouliez pas renvoyer une valeur dans une boucle par exemple, ou si vous voulez gérer le renvoi d'information de manière différente. Notez que cela ralentit légèrement le programme si c'est exécuté trop souvent car un opérateur supplémentaire est impliqué.

### Évaluation modulaire

Genius implémente l'arithmétique modulaire. Pour l'utiliser, vous avez juste à ajouter « mod <entier> » après l'expression. Exemple :

    2^(5!) * 3^(6!) mod 5

Il pourrait être possible de faire de l'arithmétique modulaire en faisant des calculs avec des entiers puis en prenant le modulo à la fin avec l'opérateur `%`, mais cela peut prendre beaucoup de temps ou être impossible si vous travaillez avec des grands nombres. Par exemple, `10^(10^10) % 6` ne fonctionne tout simplement pas (l'exposant est trop grand), alors que `10^(10^10) mod 6` est instantanée.

Vous pouvez calculer l'inverse de nombres modulo des entiers juste en utilisant des nombres rationnels (bien sûr, l'inverse doit exister). Exemples :

    10^-1 mod 101
    1/10 mod 101

Vous pouvez aussi faire de l'évaluation modulaire avec des matrices y compris prendre l'inverse, mettre à la puissance ou multiplier. Exemple :

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

Cela doit donner la matrice identité car B est l'inverse de A modulo 5.

Certaines fonctions telles que `sqrt` ou `log` fonctionnent différemment en mode modulaire. Elles vont alors fonctionner comme leur version discrète travaillant avec l'ensemble des entiers que vous avez sélectionnés, par exemple,

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

La fonction `sqrt` renvoie en fait toutes les racines carrées possibles.

### Liste des opérateurs GEL

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

    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|

- Valeur absolue ou module (si `a` est un nombre complexe).

  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. Ajoute deux nombres, matrices, fonctions ou chaînes de caractères. Si vous ajoutez une chaîne à quelque chose, le résultat ne peut être qu'une chaîne.

    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.

    a./b

- Division élément par élément.

    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

- L'opérateur modulo. Cela n'active pas le mode d'évaluation modulaire, mais renvoie juste le reste de `a/b`.

    a.%b

- L'opérateur modulo élément par élément. Renvoie le reste après la division entière élément par élément de `a./b`.

    a mod b

- Opérateur d'évaluation modulaire. L'expression `a` est évaluée modulo `b`. Consultez genius-gel-modular-evaluation. 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

- Opérateur égalité (renvoie `true` ou `false`).

    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

- Opérateur inférieur ou égal, renvoie `true` si `a` est inférieur ou égal à `b` sinon renvoie `false`.

    a>=b

- Opérateur supérieur ou égal, renvoie `true` si `a` est supérieur ou égal à `b` sinon renvoie `false`.

    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

- Et logique (and).

    a or b

- Ou logique (or).

    a xor b

- Ou exclusif logique (xor).

    not a

- Non logique (not).

    -a

- Opérateur négation.

    &a

- Référencement de variable (pour transmettre une référence à quelque chose). Consultez genius-gel-references.

    *a

- Déréférencement de variable (pour accéder à une variable référencée). Consultez genius-gel-references.

    a'

- Matrice transposée conjuguée.

    a.'

- Matrice transposée, ne conjugue pas les entrées.

    a@(b,c)

- Renvoie l'élément ligne `b` et colonne `c` d'une matrice. Si `b` et `c` sont des vecteurs alors cela renvoie les lignes et les colonnes correspondantes, soit une sous-matrice.

    a@(b,)

- Renvoie une ligne de matrice (ou des 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

- Construit un vecteur allant de `a` à `b` (ou indique une région ligne, colonne pour l'opérateur `@`). Par exemple pour obtenir les lignes 2 à 4 de la matrice `A`, nous pourrions faire

      A@(2:4,)

  puisque `2:4` renvoie un vecteur `[2,3,4]`.

    a:b:c

- Construit un vecteur allant de `a` à `c` avec un pas de `b`. Ce qui donne par exemple

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

    (a)i

- Crée un nombre imaginaire (multiplie `a` par le nombre imaginaire pur). Remarquez que normalement le nombre `i` s'écrit `1i`. Donc le nombre ci-dessus est égal à

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

Les opérateurs de comparaison (excepté l'opérateur <=> qui se comporte normalement) ne sont pas des opérateurs strictement binaires, ils peuvent en fait être regroupés comme dans une expression mathématique normale, par ex. : (1<x<=y<5) est une expression booléenne correcte qui signifie bien ce qu'elle doit, c'est-à-dire (1<x et x≤y et 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

Syntaxe :

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

Si `else` est omis alors si l'`expression1` donne `false` ou 0, `NULL` est renvoyé.

Exemples :

    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 )

Notez que `=` est traduit en `==` s'il est utilisé à l'intérieur de l'expression du `if`, donc

    if a=5 then a=a-1

est interprété comme :

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

### Boucles

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

Syntaxe :

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

Elles sont similaires à celles rencontrées dans les autres langages. Cependant puisqu'en GEL, cela doit être une expression qui doit renvoyer des valeurs, ces constructions renvoient simplement le résultat de la dernière itération ou `NULL` si aucune itération n'a eu lieu. Dans l'expression booléenne, `=` est traduit en `==` de la même manière que cela se produit pour l'instruction `if`.

#### Boucles pour (for)

Syntaxe :

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

Boucle où l'identifiant (identifier) prend toutes les valeurs comprises entre `<from>` et `<to>`, avec en option un incrément autre que 1. Elles sont plus rapides, plus simples à utiliser et plus compactes que les boucles classiques ci-dessus mais moins flexibles. L'identifiant doit être un identifiant et ne peut pas être un déréférencement. La valeur de l'identifiant est la dernière valeur prise par l'identifiant ou `<from>` si le contenu (body) de la boucle n'a jamais été évalué. Vous êtes sûr que la variable est initialisée après une boucle donc vous pouvez l'utiliser sans risque. `<from>`, `<to>` et `<increment>` ne doivent pas être complexes. Il n'est pas sûr que la valeur `<to>` soit atteinte, mais elle n'est jamais dépassée. Par exemple, ce qui suit affiche les nombres impairs de 1 à 19 :

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

#### Boucles pour chaque (foreach)

Syntaxe :

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

Pour chaque élément de la matrice, en allant de ligne en ligne et de gauche à droite, le contenu (body) est exécuté en utilisant la valeur actuelle de l'élément pour l'identifiant (identifier). Pour afficher les nombres 1, 2, 3 et 4 dans cet ordre, vous pouvez faire :

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

Si vous souhaitez parcourir les lignes et les colonnes d'une matrice, vous pouvez utiliser les fonctions « RowsOf » et « ColumnsOf » qui renvoient un vecteur des lignes ou des colonnes de la matrice. Par conséquent,

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

affiche [1,2] puis [3,4].

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

Vous pouvez aussi utiliser les instructions `break` et `continue` dans les boucles. L'instruction `continue` reprend la boucle à sa prochaine itération alors que l'instruction `break` sort de la boucle actuelle.

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

### Sommes et produits

Syntaxe :

    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>

Si vous remplacez `for` par `sum` ou `prod` alors vous obtenez une somme ou un produit à la place d'une boucle `for`. Au lieu de renvoyer la dernière valeur, cela renvoie la somme ou le produit des valeurs respectivement.

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.

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

Normalement `=` est traduit en `==` partout où GEL s'attend à une condition comme celle de la condition si (if). Par exemple,

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

sont identiques en GEL. Cependant vous devriez vraiment utiliser `==` ou `:=` lorsque vous voulez respectivement comparer ou attribuer si vous voulez éviter des erreurs et que votre code soit facile à lire.

Tous les opérateurs de comparaison (sauf l'opérateur `<=>` qui se comporte différemment) ne sont pas strictement des opérateurs binaires, ils peuvent en réalité être regroupés comme cela se produit en mathématique, par ex. : (`1<x<=y<5`) est une expression booléenne légale et signifie ce qu'elle doit, c'est-à-dire (1<x et x≤y et 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 est un langage à portée dynamique. Nous allons expliquer ce que cela signifie ci-dessous. Les variables et les fonctions normales sont à portée dynamique. Les exceptions sont les variables paramètres qui sont toujours globales.

Comme la plupart des langages de programmation, GEL possède différents types de variables. Normalement lorsqu'une variable est définie dans une fonction, elle est visible dans cette fonction et à partir de toutes les fonctions qui sont appelées (tous les contextes supérieurs). Par exemple, supposons qu'une fonction `f` définit une variable `a` puis appelle la fonction `g`. Alors la fonction `g` peut faire référence à `a`. Mais dès que la fonction `f` est quittée, la variable `a` disparaît de la portée. Par exemple, le code suivant affiche 5. La fonction `g` ne peut pas être appelée à partir du niveau supérieur (en dehors de `f` puisque `a` n'est pas défini).

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

Si vous définissez une variable à l'intérieur d'une fonction, elle va supplanter toutes variables définies dans les fonctions appelantes. Par exemple, si nous modifions le code ci-dessus et écrivons :

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

Ce code affiche toujours 5. Mais si vous appelez `g` à l'extérieur de `f` alors la valeur 10 s'affiche. Remarquez que le fait d'initialiser `a` à 5 à l'intérieur de `f` ne modifie pas la valeur de `a` au niveau (global) supérieur donc si vous contrôlez maintenant la valeur de `a`, elle sera toujours de 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.

Les fonctions sont traitées exactement comme les variables. Par conséquent, vous pouvez redéfinir localement les fonctions. Normalement (au niveau supérieur) vous ne pouvez pas redéfinir des variables et fonctions protégées mais, vous pouvez le faire localement. Considérons la session suivante :

    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

Les fonctions et variables définies au niveau supérieur sont considérées globales. Elles sont visibles de n'importe où. Comme nous l'avons déjà dit, la fonction `f` suivante ne modifie pas la valeur de `a` à 5.

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

De temps en temps, cependant, il est nécessaire de définir une variable globale à l'intérieur d'une fonction. Lorsque cela est nécessaire, utilisez la fonction `set`. La transmission d'une chaîne de caractères ou d'un identifiant précédé d'une apostrophe à cette fonction définit la variable comme globale (au niveau supérieur). Par exemple, pour initialiser `a` à la valeur 3, vous pouvez utiliser :

    set(`a,3)

ou :

    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.

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

Il existe également des variables vraiment locales, qui ne sont visibles de nulle part sauf du contexte actuel. Ainsi lorsque vous renvoyez des fonctions par valeur, il se peut que cela fasse référence à des variables non visibles à partir des contextes supérieurs et cela peut être un problème. Consultez Variables vraiment locales et Renvoi de fonctions.

### Variables paramètres

Comme dit précédemment, il existe des variables spéciales appelées paramètres qui existent dans toutes les portées. Pour déclarer un paramètre appelé `foo` et initialisé à 1, écrivez

    parameter foo = 1

À partir de cet instant, `foo` est une variable complètement globale. Attribuer une valeur à `foo` à l'intérieur d'une fonction, modifie la variable dans tous les contextes, ce qui signifie que les fonctions ne possèdent pas de copie privée des paramètres.

Si vous annulez la définition comme paramètre en utilisant la fonction `undefine`, la variable cesse d'être un paramètre.

Certains paramètres sont internes à Genius et modifient son comportement.

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

Exemple :

    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.

Lorsque vous utilisez des fonctions qui renvoient des valeurs à travers des références dans sa liste d'argument, il suffit de transmettre le nom de la variable précédée d'une esperluette. Par exemple, le code suivant calcule une valeur propre d'une matrice `A` avec un vecteur propre initial pressenti `x` et enregistre le vecteur propre calculé dans la variable appelée `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.

Les références s'expliquent mieux par un exemple :

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

Maintenant `a` contient 2. Vous pouvez également référencer des fonctions :

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

donne 4.

### Valeurs à gauche (lvalues)

Une valeur à gauche est la partie à gauche d'une attribution. En d'autres mots, une valeur à gauche est la chose dans laquelle vous attribuez quelque chose. Des valeurs à gauche valides sont :

`a`

- Identifiant. Ici nous attribuons une valeur à la variable de nom `a`.

`*a`

- Déréférence un identifiant. Cela attribue une valeur à ce que vers quoi la variable `a` pointe.

`a@(<région>)`

- Une région d'une matrice. Ici la région est indiquée normalement comme avec l'opérateur habituel @() et peut être une entrée unique ou une région entière de la matrice.

Exemples :

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

Notez que `:=` et `=` peuvent être utilisés indifféremment l'un à la place de l'autre. Sauf si l'attribution apparaît dans une condition. Il est donc plus sûr d'utiliser uniquement `:=` lorsque vous voulez faire une attribution et `==` lorsque vous voulez faire une comparaison.

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

Par exemple, si vous voulez vérifier les arguments de votre fonction. Vous pouvez utiliser le code suivant.

    function f(M) = (
      if not IsMatrix (M) then (
        error ("M n'est pas une matrice !");
        bailout
      );
      ...
    )

### Syntaxe de haut-niveau

La syntaxe est légèrement différente si vous saisissez des instructions au niveau supérieur plutôt que lorsque vous êtes entre parenthèses ou à l'intérieur de fonctions. Au niveau supérieur, un retour à la ligne a le même effet qu'un appui sur la touche Entrée en ligne de commande. Par conséquent, considérez vos programmes comme une suite de lignes saisie en ligne de commande. En particulier, vous n'avez pas besoin de saisir le séparateur à la fin d'une ligne (à moins que cela ne soit une partie de plusieurs instructions à l'intérieur de parenthèses).

Le code suivant provoque une erreur lorsqu'il est saisi au niveau supérieur d'un programme alors qu'il fonctionne très bien dans une fonction.

    if QuelqueChose() then
      FaireQuelqueChose()
    else
      FaireAutreChose()

Le problème est que lorsque l'Outil de maths Genius rencontre la fin de la ligne après la seconde ligne, il décide que l'instruction est complète et il l'exécute. Après l'exécution l'Outil de maths Genius se rend à la ligne suivante, voit l'instruction `else` et affiche une erreur de syntaxe. Pour régler ce problème, utilisez des parenthèses. L'Outil de maths Genius ne sera pas satisfait tant qu'il n'aura pas trouvé que toutes les parenthèses sont fermées.

    if QuelqueChose() then(
      FaireQuelqueChose()
    ) else (
      FaireAutreChose()
    )

### Renvoi de fonction

Il est possible de renvoyer des fonctions en tant que donnée. De cette manière, vous pouvez écrire une fonction qui construit des fonctions dans un but précis en fonction de certains paramètres. Le point délicat est de savoir quelles variables sont visibles par la fonction construite. La façon dont cela fonctionne dans GEL est que, lorsqu'une fonction renvoie une autre fonction, tous les identifiants qui étaient référencés dans le corps de la fonction mère, et qui deviendraient hors de portée, sont en fait ajoutés dans un dictionnaire privé de la fonction renvoyée. Ainsi la fonction voit toutes les variables qui étaient à sa portée au moment où elle a été définie. Par exemple, nous pouvons définir ainsi une fonction qui renvoie une fonction qui ajoute 5 à son argument :

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

Notez que la fonction ajoute `k` à `x`. Vous pouvez l'utiliser ainsi.

    g = f();
    g(5)

et `g(5)` doit renvoyer 10.

Une chose à noter est que la valeur de `k` utilisée est celle qui est en cours lorsque la fonction `f` a terminé son exécution. Par exemple :

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

renvoie une fonction qui ajoute 10 à son argument plutôt que 5. La raison est que le dictionnaire supplémentaire est créé uniquement lorsque le contexte dans lequel la fonction a été définie, se termine, c'est-à-dire lorsque la fonction `f` renvoie. C'est cohérent avec la manière dont on s'attend à ce que la fonction `r` fonctionne à l'intérieur de la fonction `f` d'après les règles sur la portée des variables dans GEL. Les seules variables ajoutées au dictionnaire supplémentaire sont celles qui sont présentes dans le contexte qui se termine et n'existe plus. Les variables utilisées dans la fonction, qui sont toujours dans des contextes valides, fonctionnent comme d'habitude, en utilisant la valeur actuelle de la variable. La seule différence, c'est pour les variables et les fonctions globales. Tous les identifiants qui référencent des variables globales au moment de la définition de la fonction ne sont pas ajoutés au dictionnaire privé. C'est pour éviter beaucoup de travail non nécessaire lors du renvoi de fonctions et cela ne pose que rarement problème. Par exemple, supposons que vous supprimiez le « k= 5 » de la fonction `f` et qu'au niveau supérieur vous définissiez `k` à 5 par exemple. Alors lorsque vous exécutez `f`, la fonction `r` ne met pas `k` dans le dictionnaire privé parce qu'il était global (au niveau supérieur) au moment de la définition de `r`.

Parfois il est préférable d'avoir un meilleur contrôle sur la façon dont les variables sont copiées dans le dictionnaire privé. Depuis la version 1.0.7, vous pouvez spécifier quelles variables sont copiées dans le dictionnaire privée en mettant des crochets carrés supplémentaires après les arguments contenant la liste des variables qui seront copiées, séparées par des virgules. Si vous faites cela alors les variables sont copiées dans le dictionnaire privé au moment de la définition de la fonction et le dictionnaire privé n'est pas modifié ensuite. Par exemple,

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

renvoie une fonction qui, lorsqu'elle est appelée, ajoute 5 à ses arguments. La copie locale de `k` a été créée lorsque la fonction a été définie.

Lorsque vous désirez que la fonction n'ait pas de dictionnaire privé alors mettez des crochets carrés vides après la liste d'arguments. Alors aucun dictionnaire privé n'est créé. Ce méchanisme est utile pour améliorer l'efficacité des fonctions qui n'ont pas besoin de dictionnaire privé, ou encore si vous voulez que la fonction utilise les variables dans leur état au moment où elle est appelée. Par exemple, supposons que vous vouliez que la fonction renvoyée par `f` recherche la valeur de `k` dans le niveau supérieur bien qu'il y ait une variable locale portant le même nom pendant la définition. Le code suivant

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

renvoie 20 et non pas 15, ce qui se produirait si une variable `k` contenant une valeur 5 était ajoutée dans le dictionnaire privé.

### Variables locales vraies

Lors de la transmission de fonctions dans d'autres fonctions, la portée normale des variables peut être indésirable. Par exemple :

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

vous souhaitez probablement que la fonction `r` lorsqu'elle est transmise à `g` dans `f`, puisse voir `k` comme 10 plutôt que 5 afin que le code renvoie 11 et pas 6. Cependant, tel que c'est écrit, la fonction lorsqu'elle est exécutée voit la variable `k` qui est égale à 5. Il y a deux façons de résoudre cela. L'une est que la fonction `r` obtienne `k` dans un dictionnaire privé en utilisant la notation crochet carré de la section Renvoi de fonctions.

Mais il y a une autre solution. Depuis la version 1.0.7 de Genius, il existe des variables vraiment locales. Ce sont des variables qui ne sont visibles qu'à partir du contexte actuel, et pas par les fonctions appelées. Nous pouvons définir `k` comme une variable locale dans la fonction `f`. Pour faire cela, ajoutez une instruction `local` comme première instruction dans la fonction (cela doit toujours être la première instruction de la fonction). Vous pouvez également transformer tous les arguments en variables locales, c'est-à-dire

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

Dans ce cas, le code fonctionne comme attendu et affiche 11. Notez que l'instruction `local` initialise toutes les variables référencées (sauf les arguments de la fonction) à `null`.

Si toutes les variables doivent être créées localement, vous pouvez utiliser un astérisque à la place d'une liste de variables. Dans ce cas, les variables ne sont pas initialisées tant qu'elles ne sont pas définies bien sûr. La définition suivante de `f` fonctionne également :

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

Si vous modifiez l'emplacement d'installation de la bibliothèque, vous devrez d'abord la compiler avec la commande `genius --compile loader.gel > lib.cgel`

### Chargement de programmes

Imaginons que vous ayiez un programme d'une certaine taille que vous avez écrit dans un fichier et que vous vouliez lire ce fichier. Dans ce cas, il y a deux options. Vous pouvez conserver les fonctions que vous utilisez le plus souvent dans le fichier `~/.geniusinit` ou, si vous voulez charger un fichier au milieu d'une session, (ou à partir d'un autre fichier), vous pouvez saisir `load <liste de noms de fichier>` au prompt. Cela doit être réalisé au niveau supérieur et pas à l'intérieur d'une fonction ou d'autres choses et cela ne peut pas faire partie d'une expression. La syntaxe est également légèrement différente du reste de genius, plus proche de celle d'un shell. Vous pouvez saisir le nom du fichier entre guillemets. Si vous utilisez les guillemets simples '', vous obtenez exactement la chaîne saisie mais si vous utilisez les guillemets doubles "", les caractères spéciaux ne seront pas échappés comme ils le sont pour les chaînes de caractères. Exemple :

    load programme1.gel programme2.gel
    load "Etrange nom de fichier avec des ESPACES.gel"

Il existe également des commandes intégrées `cd`, `pwd` et `ls`. `cd` qui ne prenne qu'un seul argument, la commande `ls` ne prend qu'un seul argument qui est comme le « glob » dans le shell unix (c'est-à-dire vous pouvez utiliser des caractères génériques). La commande `pwd` ne prend pas d'argument. Par exemple :

    cd repertoire_contenant_des_programmes_gel
    ls *.gel

## Matrices en GEL

Genius prend en charge les vecteurs et les matrices et possède une importante bibliothèque de fonctions pour la manipulation des matrices et l'algèbre linéaire.

### Saisie de matrices

Pour saisir des matrices, vous pouvez utiliser l'une des deux syntaxes suivantes. Soit vous saisissez la matrice sur une seule ligne, en séparant les valeurs par des virgules et les lignes par des point-virgules soit vous saisissez chaque rangée sur une ligne en séparant les valeurs par des virgules. Vous pouvez également combiner les deux méthodes. Ainsi pour saisir une matrice 3x3 contenant les nombres 1 à 9, vous pouvez saisir

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

ou

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

Toutefois, n'utilisez pas à la fois « ; » et un retour chariot sur la même ligne.

Vous pouvez aussi utiliser les fonctionnalités de complétion pour saisir des matrices. Par exemple, vous pouvez saisir :

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

pour obtenir

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

De même, vous pouvez construire des matrices à partir de vecteurs ou d'autres choses du même type.

Notez que les éléments non spécifiés sont initialisés à 0, donc

    [1, 2, 3
     4, 5
     6]

donne au final

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

Lorsque les matrices sont évaluées, elles sont parcourues dans le sens des lignes, exactement de la même façon que l'opérateur `M@(j)`.

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

Vous pouvez obtenir la matrice transposée conjuguée grâce à l'opérateur `'`. Cela signifie que la valeur dans la `i`ième colonne et la `j`ième ligne est le complexe conjugué de la valeur dans la `j`ième colonne et la `i`ième ligne de la matrice d'origine. Dans l'exemple :

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

il faut transposer la deuxième matrice pour permettre la multiplication des matrices. Si vous voulez juste transposer une matrice sans la conjuguer, vous devez utiliser l'opérateur `.'`. Par exemple :

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

En général, lorsque Genius calcule la base d'un espace vectoriel (par exemple avec la fonction `NullSpace`) il renvoie la base sous la forme d'une matrice dans laquelle les colonnes sont les vecteurs de la base. Cela signifie que lorsque Genius parle d'un sous-espace linéaire, cela désigne une matrice dont l'espace des colonnes est le sous-espace linéaire concerné.

Notez que Genius peut se souvenir d'un certaine nombre de propriétés d'une matrice. Par exemple, il se souvient qu'une matrice est sous une forme réduite. Si beaucoup d'appels à des fonctions qui utilisent en interne une forme réduite, sont effectués, vous pouvez réduire la matrice une fois pour toute auparavant. Les appels successifs à la fonction `rref` seront très rapides.

## 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

Actuellement les polynômes à une variable sont juste des vecteurs lignes dont les valeurs sont les coefficients. La puissance du terme est la position dans le vecteur, la première étant 0. Ainsi,

    [1,2,3]

représente le polynôme

    1 + 2*x + 3*x^2

Vous pouvez ajouter, soustraire et multiplier des polynômes en utilisant respectivement les fonctions `AddPoly`, `SubtractPoly` et `MultiplyPoly`. Vous pouvez afficher un polynôme en utilisant la fonction `PolyToString`. Par exemple,

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

donne

    3*y^2 + 2*y + 1

Vous pouvez également obtenir une représentation fonctionnelle du polynôme afin de pouvoir l'évaluer. Pour cela, utilisez `PolyToFunction` qui renvoie une fonction anonyme.

    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 genius-gel-function-list-polynomials 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.

Pour construire un ensemble à partir d'un vecteur, utilisez la fonction `MakeSet`. Actuellement, cela renvoie juste un nouveau vecteur où chaque élément est unique.

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

De manière similaire, il existe des fonctions `Union`, `Intersection`, `SetMinus` dont le but est assez intuitif. Par exemple :

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

Notez qu'aucun ordre n'est garanti pour les valeurs renvoyées. Si vous souhaitez trier le vecteur, vous devez utiliser la fonction `SortVector`.

Pour tester l'appartenance, il existe les fonctions `IsIn` et `IsSubset` qui renvoient une valeur booléenne. Par exemple,

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

La syntaxe `IsIn(x,X)` est bien sûr équivalente à `IsSubset([x],X)`. Notez que puisque l'ensemble vide est un sous-ensemble de tous les ensembles, `IsSubset(null,X)` est toujours vrai.

## Liste des fonctions GEL

Pour obtenir de l'aide sur une fonction spécifique à partir de la console, saisissez :

    help NomDeLaFonction

### Commandes

help

-     help

      help NomDeLaFonction

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

load

-     load "fichier.gel"

  Charge un fichier dans l'interpréteur. Le contenu du fichier s'exécute comme s'il était saisi en ligne de commande.

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.

AskString

-     AskString (requête)

      AskString (requête, défaut)

  Pose une question et permet à l'utilisateur de saisir une chaîne de caractères qui est ensuite renvoyée. Si l'utilisateur annule ou ferme la fenêtre alors `null` est renvoyé. L'exécution du programme est bloquée jusqu'à ce que l'utilisateur réponde. Si `défaut` est fourni alors il est pré-saisi pour que l'utilisateur n'ait qu'à appuyer sur Entrée.

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 et exécute une fonction avec elle-même `n` fois en transmettant l'argument `x`. Cela renvoie `x` si `n` vaut 0. Exemple :

      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)

  Fonction identité, renvoie son argument.

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.

display

-     display (chaîne,expr)

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

error

-     error (chaîne)

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

exit

-     exit

  Alias : `quit`

  Quitte le programme.

false

-     false

  Alias : `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.

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.

set

-     set (id,val)

  Définit une variable globale. L'`identifiant` (id) peut être soit une chaîne de caractères, soit un identifiant précédé d'une apostrophe comme ci-dessous. Par exemple :

      set(`x,1)

  définit la variable globale `x` à 1.

string

-     string (s)

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

true

-     true

  Alias : `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.

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

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.

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

  Tolérance pour la fonction `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

  Tolérance pour la fonction `GaussDistribution`.

IntegerOutputBase

-     IntegerOutputBase = nombre

  Base de sortie pour les entiers.

IsPrimeMillerRabinReps

-     IsPrimeMillerRabinReps = nombre

  Nombre de tests supplémentaires de Miller-Rabin à lancer sur un nombre avant de le déclarer comme premier dans `IsPrime`.

LinePlotDrawLegends

-     LinePlotDrawLegends = true

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

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.

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

  Fonction utilisée pour l'intégration numérique dans la fonction `NumericalIntegral`.

NumericalIntegralSteps

-     NumericalIntegralSteps = nombre

  Nombre d'étapes à réaliser pour la fonction `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`.

  Cela affecte principalement la façon dont les matrices et les fractions sont affichées et est utile pour le copier/coller vers des documents. Par exemple, vous pouvez définir ce paramètre à « latex » par :

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

SumProductNumberOfTries

-     SumProductNumberOfTries = nombre

  Nombre d'itérations à essayer pour les fonctions `InfiniteSum` et `InfiniteProduct`.

SumProductSFS

-     SumProductSFS = nombre

  Nombre d'étapes successives pour atteindre la tolérance pour les fonctions `InfiniteSum` et `InfiniteProduct`.

SumProductTolerance

-     SumProductTolerance = nombre

  Tolérance pour les fonctions `InfiniteSum` et `InfiniteProduct`.

SurfacePlotVariableNames

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

  Indique à Genius les noms de variables à utiliser comme noms par défaut pour les fonctions de tracé de surface utilisant `SurfacePlot`. Notez que le `z` ne fait pas référence à l'axe dépendant (vertical) mais à la variable complexe z indépendante `z=x+iy`.

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

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

  Consultez Mathworld pour plus d'informations.

EulerConstant

-     EulerConstant

  Alias : `gamma`

  Constante d'Euler gamma, parfois appelée la constante d'Euler-Mascheroni.

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

GoldenRatio

-     GoldenRatio

  Le nombre d'or.

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

Gravity

-     Gravity

  Accélération de la chute libre au niveau de la mer.

  Consultez Wikipedia pour plus d'informations.

e

-     e

  La base du logarithme naturel. `e^x` est la fonction exponentielle `exp`. C'est approximativement le nombre 2.71828182846...

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

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

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

### Nombres

AbsoluteValue

-     AbsoluteValue (x)

  Alias : `abs`

  Valeur absolue d'un nombre et, si `x` est une grandeur complexe, le module de `x`, c'est-à-dire la distance de `x` à l'origine.

  Consultez Wikipedia, Planetmath (valeur absolue), Planetmath (module), Mathworld (valeur absolue) ou Mathworld (module complexe) pour plus d'informations.

Chop

-     Chop (x)

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

ComplexConjugate

-     ComplexConjugate (z)

  Alias : `conj` `Conj`

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

  Consultez Wikipedia pour plus d'informations.

Denominator

-     Denominator (x)

  Renvoie le dénominateur d'un nombre rationnel.

  Consultez Wikipedia pour plus d'informations.

FractionalPart

-     FractionalPart (x)

  Renvoie la partie fractionnelle d'un nombre.

  Consultez Wikipedia pour plus d'informations.

Im

-     Im (z)

  Alias : `ImaginaryPart`

  Renvoie la partie imaginaire d'un nombre complexe.

  Consultez Wikipedia pour plus d'informations.

IntegerQuotient

-     IntegerQuotient (m,n)

  Division sans reste.

IsComplex

-     IsComplex (nbre)

  Vérifie si l'argument est un nombre complexe (non réel).

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)

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

IsGaussInteger

-     IsGaussInteger (nbre)

  Alias : `IsComplexInteger`

  Vérifie si l'argument peut être un entier complexe.

IsInteger

-     IsInteger (nbre)

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

IsNonNegativeInteger

-     IsNonNegativeInteger (nbre)

  Vérifie si l'argument est un entier réel non négatif.

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.

  Consultez Wikipedia pour plus d'informations.

Re

-     Re (z)

  Alias : `RealPart`

  Renvoie la partie réelle d'un nombre complexe.

  Consultez Wikipedia pour plus d'informations.

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

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

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

log

-     log (x)

      log (x,b)

  Logarithme de `x` dans la base `b` (appelle la fonction `DiscreteLog dans le mode modulo). Si la base n'est pas donnée, `e` est utilisée.`

log10

-     log10 (x)

  Logarithme base 10 de `x`.

log2

-     log2 (x)

  Alias : `lg`

  Logarithme base 2 de `x`.

max

-     max (a,params...)

  Alias : `Max` `Maximum`

  Renvoie le maximum des arguments ou de la matrice.

min

-     min (a,params...)

  Alias : `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...)

  Génère aléatoirement des entiers dans l'intervalle `[0,max)`. Si taille est donné alors une matrice (si deux nombres sont fournis) ou un vecteur (si un seul est fourni) de la taille indiquée est renvoyé. Par exemple,

      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`

  La racine carrée. Au cours de calculs en mode modulaire, certains entiers renvoient soit `null` ou un vecteur contenant les racines carrées. Exemples :

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

  Consultez Planetmath pour plus d'informations.

trunc

-     trunc (x)

  Alias : `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).

  Consultez Wikipedia or Mathworld pour plus d'informations.

atanh

-     atanh (x)

  Alias : `arctanh`

  Fonction arctanh (tangente hyperbolique inverse).

atan2

-     atan2 (y, x)

  Alias : `arctan2`

  Calcule la fonction arctan2. Si `x>0` alors renvoie `atan(y/x)`. Si `x<0` alors cela renvoie `sign(y) * (pi - atan(|y/x|)`. Si `x=0` cela renvoie `sign(y) * pi/2`. `atan2(0,0)` renvoie 0 plutôt que d'échouer.

  Consultez Wikipedia ou Mathworld pour plus d'informations.

cos

-     cos (x)

  Calcule la fonction cosinus.

  Consultez Planetmath pour plus d'informations.

cosh

-     cosh (x)

  Calcule la fonction cosinus hyperbolique.

  Consultez Planetmath pour plus d'informations.

cot

-     cot (x)

  Fonction cotangente.

  Consultez Planetmath pour plus d'informations.

coth

-     coth (x)

  Fonction cotangente hyperbolique.

  Consultez Planetmath pour plus d'informations.

csc

-     csc (x)

  Fonction cosécante.

  Consultez Planetmath pour plus d'informations.

csch

-     csch (x)

  Fonction cosécante hyperbolique.

  Consultez Planetmath pour plus d'informations.

sec

-     sec (x)

  Fonction sécante.

  Consultez Planetmath pour plus d'informations.

sech

-     sech (x)

  Fonction sécante hyperbolique.

  Consultez Planetmath pour plus d'informations.

sin

-     sin (x)

  Calcule la fonction sinus.

  Consultez Planetmath pour plus d'informations.

sinh

-     sinh (x)

  Calcule la fonction sinus hyperbolique.

  Consultez Planetmath pour plus d'informations.

tan

-     tan (x)

  Calcule la fonction tangente.

  Consultez Planetmath pour plus d'informations.

tanh

-     tanh (x)

  Fonction tangente hyperbolique.

  Consultez Planetmath pour plus d'informations.

### Théorie des nombres

AreRelativelyPrime

-     AreRelativelyPrime (a,b)

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

BernoulliNumber

-     BernoulliNumber (n)

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

  Consultez Wikipedia ou Mathworld pour plus d'informations.

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.

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

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

  Consultez Wikipedia or Planetmath ou Mathworld pour plus d'informations.

ExactDivision

-     ExactDivision (n,d)

  Renvoie `n/d` mais seulement si `d` divise `n`. Si `d` ne divise pas `n` alors cette fonction ne renvoie rien d'utile. Cette fonction est beaucoup plus rapide pour les très grands nombres que l'opération `n/d`, mais bien sûr utile seulement si vous savez que la division est exacte.

Factorize

-     Factorize (n)

  Renvoie la factorisation d'un nombre sous la forme d'une matrice. La première ligne contient les nombres premiers dans la factorisation (y compris 1) et la seconde ligne sont les puissances. Par exemple :

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

  Consultez Wikipedia pour plus d'informations.

Factors

-     Factors (n)

  Renvoie tous les facteurs de `n` dans un vecteur. Cela inclut tous les facteurs non premiers également mais aussi 1 et le nombre lui-même. Ainsi par exemple pour afficher tous les nombres parfaits (ceux qui sont la somme de leurs facteurs) jusqu'au nombre 1000, vous pouvez écrire (ce n'est bien sûr pas efficace) :

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

FermatFactorization

-     FermatFactorization (n,tentatives)

  Essaie la factorisation de Fermat de `n` sous la forme `(t-s)*(t+s)`, si c'est possible, renvoie `t` et `s` sous la forme d'un vecteur sinon renvoie `null`. L'argument `tentatives` indique le nombre d'essais avant d'abandonner.

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

  Consultez Wikipedia pour plus d'informations.

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)

  Calcule le logarithme discret de n base `b` dans Fq, le corps fini d'ordre `q` (`q` est un nombre premier), en utilisant la base de facteur `S`. `S` doit être une colonne de nombres premiers avec éventuellement la deuxième colonne pré-calculée par `IndexCalculusPrecalculation`.

IndexCalculusPrecalculation

-     IndexCalculusPrecalculation (b,q,S)

  Lance l'étape de calcul préliminaire de `IndexCalculus` pour le logarithme base `b` dans Fq, le corps fini d'ordre `q` (`q` est un nombre premier), pour la base de facteur `S` (où `S` doit être une colonne de nombres premiers). Les logarithmes sont pré-calculés et renvoyés dans la deuxième colonne.

IsEven

-     IsEven (n)

  Teste si un entier est pair.

IsMersennePrimeExponent

-     IsMersennePrimeExponent (p)

  Teste si un nombre entier positif `p` est un nombre premier de Mersenne, c'est-à-dire si 2p-1 est premier. Il s'agit d'une recherche dans une table de valeurs connues qui est assez petite. Consultez également MersennePrimeExponents et LucasLehmer.

  Consultez Wikipedia, Planetmath, Mathworld ou GIMPS pour plus d'informations.

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)

  Vérifie qu'un entier est une puissance parfaite, ab.

IsPerfectSquare

-     IsPerfectSquare (n)

  Vérifie qu'un entier est un carré parfait d'un entier. Le nombre doit être un vrai entier. Les entiers négatifs ne peuvent bien sûr jamais être des carrés de vrais entiers.

IsPrime

-     IsPrime (n)

  Teste la primalité des entiers ; pour les nombres inférieurs à 2,5e10 la réponse est déterministe (si l'hypothèse de Riemann est vérifiée). Pour des nombres plus grands, la probabilité d'une erreur de détermination dépend du paramètre `IsPrimeMillerRabinReps`. C'est-à-dire la probabilité d'une erreur de détermination vaut 1/4 à la puissance `IsPrimeMillerRabinReps`. La valeur par défaut de 22 mène à une probabilité d'environ 5.7e-14.

  Si `false` (faux) est renvoyé, vous êtes sûr que le nombre est composé. Si vous voulez être absolument certain d'avoir un nombre premier vous pouvez utiliser la fonction `MillerRabinTestSure` mais cela peut prendre beaucoup plus de temps.

  Consultez Planetmath ou Mathworld pour plus d'informations.

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)

  Teste si `n` est un nombre pseudopremier en base `b` mais pas un nombre premier c'est-à-dire si `b^(n-1) == 1 mod n`. Cela appelle la fonction `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).

  Consultez Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

LucasNumber

-     LucasNumber (n)

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

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Wikipedia, Planetmath, Mathworld ou GIMPS pour plus d'informations.

MillerRabinTest

-     MillerRabinTest (n,reps)

  Utilise le test de primalité de Miller-Rabin sur `n`, en faisant `reps` essais. La probabilité d'une erreur de détermination est `(1/4)^reps`. Il est probablement préférable d'utiliser la fonction `IsPrime` puisqu'elle est plus rapide et meilleure pour les entiers les plus petits.

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

MillerRabinTestSure

-     MillerRabinTestSure (n)

  Utilise le test de primalité de Miller-Rabin sur `n` avec suffisamment d'essais pour qu'en supposant la véracité de l'hypothèse de Riemann généralisée, le résultat soit déterministe.

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Planetmath ou Mathworld pour plus d'informations.

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

  La fonction utilise la fonction `mpz_nextprime` de GMP qui utilise elle-même le test de probabilité de Miller-Rabin (consultez aussi MillerRabinTest). La probabilité d'une erreur de détermination n'est pas ajustable mais suffisamment faible dans tous les cas pratiques.

  Consultez Planetmath ou Mathworld pour plus d'informations.

PadicValuation

-     PadicValuation (n,p)

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

  Consultez Planetmath pour plus d'informations.

PowerMod

-     PowerMod (a,b,m)

  Calcule `a^b mod m`. La puissance `b` de `a` modulo `m`. Il n'est pas nécesssaire d'utiliser cette fonction car elle est utilisée automatiquement en mode modulaire. Par conséquent, `a^b mod m` est aussi rapide.

Prime

-     Prime (n)

  Alias : `prime`

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

PrimeFactors

-     PrimeFactors (n)

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

  Consultez Mathworld pour plus d'informations.

PseudoprimeTest

-     PseudoprimeTest (n,b)

  Test de pseudoprimalité, renvoie `true` (vrai) si et seulement si `b^(n-1) == 1 mod n`

  Consultez Planetmath ou Mathworld pour plus d'informations.

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Planetmath ou Mathworld pour plus d'informations.

StrongPseudoprimeTest

-     StrongPseudoprimeTest (n,b)

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

gcd

-     gcd (a,params...)

  Alias : `GCD`

  Plus grand commun diviseur d'entiers (PGCD, en anglais « Greatest Common Divisor »). Vous pouvez fournir autant d'entiers que vous voulez dans la liste d'arguments ou vous pouvez fournir un vecteur ou une matrice d'entiers. Si vous fournissez plus d'une matrice de la même taille alors le PGCD est recherché élément par élément.

  Consultez Planetmath ou Mathworld pour plus d'informations.

lcm

-     lcm (a,params...)

  Alias : `LCM`

  Plus petit commun multiple d'entiers (PPCM, en anglais « Least Common Multiplier »). Vous pouvez fournir autant d'entiers que vous voulez dans la liste d'arguments ou vous pouvez fournir un vecteur ou une matrice d'entiers. Si vous fournissez plus d'une matrice de la même taille alors le PPCM est recherché élément par élément.

  Consultez Planetmath ou Mathworld pour plus d'informations.

### Manipulation de matrices

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)

  Compte le nombre de colonnes nulles d'une matrice. Par exemple, après avoir réduit une matrice suivant les colonnes, vous pouvez utiliser cette fonction pour obtenir la dimension du noyau. Consultez `cref` et `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.

  Consultez Wikipedia pour plus d'informations.

DotProduct

-     DotProduct (u,v)

  Renvoie le produit scalaire de deux vecteurs. Les vecteurs doivent être de même taille. Aucune conjugaison n'est faite donc c'est une forme bilinéaire même dans le cas de nombres complexes.

  Consultez Planetmath pour plus d'informations.

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

  Consultez Mathworld pour plus d'informations.

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

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Wikipedia ou Planetmath pour plus d'informations.

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)

  Vérifie si une matrice est constituée de nombres entiers (non complexe).

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.

  Consultez Wikipedia pour plus d'informations.

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

  Consultez Wikipedia pour plus d'informations.

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)

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

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`

  Construit une matrice diagonale à partir d'un vecteur.

  Consultez Wikipedia ou Planetmath pour plus d'informations.

MakeVector

-     MakeVector (A)

  Construit un vecteur colonne à partir d'une matrice en mettant les colonnes les unes au dessus des autres. Renvoie `null` si `null` est fourni.

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.

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)

  Calcule la somme des carrés pour chaque ligne d'une matrice.

RowsOf

-     RowsOf (M)

  Renvoie les lignes d'une matrice dans un vecteur vertical. Chaque élément du vecteur est un vecteur horizontal qui correspond à chaque ligne de `M`. Cette fonction est utile si vous désirez faire une boucle sur les lignes d'une matrice comme par exemple, `for r in RowsOf(M) do quelquechose(r)`.

SetMatrixSize

-     SetMatrixSize (M,lignes,colonnes)

  Fabrique une nouvelle matrice de la taille spécifiée à partir de l'ancienne. C'est-à-dire crée une nouvelle matrice dans laquelle est recopiée l'ancienne. Les entrées qui ne rentrent pas sont retirées et l'espace supplémentaire est complété par des zéros. Si `lignes` ou `colonnes` valent zéro alors `null` est renvoyé.

ShuffleVector

-     ShuffleVector (v)

  Mélange les éléments d'un vecteur. Renvoie `null` si `null` est fourni

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)

  Renvoie la matrice unitaire auxiliaire de taille `n`. C'est une matrice carrée dont les éléments sont tous nuls sauf ceux de la super-diagonale qui valent 1. C'est la matrice bloc de Jordan nilpotent à valeurs propres nulles.

  Consultez Planetmath ou Mathworld pour plus d'informations sur la forme canonique de Jordan.

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.

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

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

CommutationMatrix

-     CommutationMatrix (m, n)

  Renvoie la matrice de permutation K(m,n) qui est l'unique matrice m*n par m*n telle que K(m,n) * MakeVector(A) = MakeVector(A.') pour toutes matrices A de taille m par n.

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

  Consultez Planetmath pour plus d'informations.

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.

DeterminantalDivisorsInteger

-     DeterminantalDivisorsInteger (M)

  Renvoie les « determinantal divisors » d'une matrice d'entiers (et non pas son polynôme caractéristique).

DirectSum

-     DirectSum (M,N...)

  Somme directe de matrices.

DirectSumMatrixVector

-     DirectSumMatrixVector (v)

  Somme directe d'un vecteur de matrices.

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

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

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

  Consultez Planetmath pour plus d'informations.

HankelMatrix

-     HankelMatrix (c,r)

  Matrice de Hankel.

HilbertMatrix

-     HilbertMatrix (n)

  Matrice de Hilbert d'ordre `n`.

  Consultez Planetmath pour plus d'informations.

Image

-     Image (T)

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

InfNorm

-     InfNorm (v)

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

InvariantFactorsInteger

-     InvariantFactorsInteger (M)

  Renvoie les facteurs invariants d'une matrice carrée (pas sa caractéristique).

InverseHilbertMatrix

-     InverseHilbertMatrix (n)

  Matrice inverse de Hilbert d'ordre `n`.

  Consultez Planetmath pour plus d'informations.

IsHermitian

-     IsHermitian (M)

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

  Consultez Planetmath pour plus d'informations.

IsInSubspace

-     IsInSubspace (v,W)

  Teste si un vecteur appartient à un sous-espace.

IsInvertible

-     IsInvertible (n)

  Indique si une matrice (ou un nombre) est inversible (une matrice entière est inversible si et seulement si elle est inversible sur les entiers).

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

IsUnitary

-     IsUnitary (M)

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

JordanBlock

-     JordanBlock (n,lambda)

  Alias : `J`

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

Kernel

-     Kernel (T)

  Renvoie le noyau d'une transformation linéaire.

  (consultez NullSpace)

LUDecomposition

-     LUDecomposition (A, L, U)

  Calcule la décomposition LU de `A` et enregistre le résultat dans `L` et `U` qui doivent être des références. Renvoie `true` (vrai) en cas de réussite. Par exemple, supposons que A est une matrice carrée, alors après avoir exécuté :

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

  Vous obtenez la matrice inférieure dans une variable appelée `L` et la matrice supérieure dans une variable appelée `U`.

  C'est la décomposition LU d'une matrice appelée aussi réduction de Crout ou de Cholesky (ISBN 0-201-11577-8 pp.99-103). La matrice triangulaire supérieure est composée d'une diagonale de 1. Ce n'est pas la méthode de Doolittle pour laquelle la diagonale de 1 est dans la matrice inférieure.

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

  Consultez Planetmath ou Mathworld pour plus d'informations.

Minor

-     Minor (M,i,j)

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

  Consultez Planetmath pour plus d'informations.

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

  Consultez Planetmath pour plus d'informations.

Nullity

-     Nullity (M)

  Alias : `nullity`

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

  Consultez Planetmath pour plus d'informations.

OrthogonalComplement

-     OrthogonalComplement (M)

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

PivotColumns

-     PivotColumns (M)

  Renvoie les numéros des colonnes pivot d'une matrice, c'est-à-dire quelles sont les colonnes d'une matrice réduite qui contiennent 1 en première position. Renvoie également dans quelles lignes se trouvent ces pivots.

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)

  Calcule la décomposition QR d'une matrice carrée `A`, renvoie la matrice triangulaire supérieure `R` et définit `Q` comme la matrice orthogonale (unitaire). `Q` doit être une référence. Si vous ne voulez pas qu'elle soit renvoyée, utilisez `null`. Par exemple :

      genius> R = QRDecomposition(A,&Q)

  Vous obtenez la matrice supérieure dans une variable appelée `R` et la matrice orthogonale (unitaire) dans `Q`.

  Consultez Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

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

  Consultez Planetmath pour plus d'informations sur le quotient de Rayleigh.

Rank

-     Rank (M)

  Alias : `rank`

  Renvoie le rang d'une matrice.

  Consultez Planetmath pour plus d'informations.

RosserMatrix

-     RosserMatrix ()

  Matrice de Rosser, un problème classique de test de valeurs propres symétriques.

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)

  Forme normale de Smith pour les corps (se terminera par des 1 sur la diagonale).

SmithNormalFormInteger

-     SmithNormalFormInteger (M)

  Forme normale de Smith pour les matrices entières carrées (pas sa caractéristique).

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

  Renvoie la matrice de Toeplitz construite à partir de la première colonne c et (éventuellement) de la première ligne r. Si seule la colonne c est fournie alors elle est conjuguée et la version non conjuguée est utilisée pour la première ligne pour fournir une matrice hermitienne (si le premier élément est réel bien sûr).

  Consultez Planetmath pour plus d'informations.

Trace

-     Trace (M)

  Alias : `trace`

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

  Consultez Planetmath pour plus d'informations.

Transpose

-     Transpose (M)

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

  Consultez Planetmath pour plus d'informations.

VandermondeMatrix

-     VandermondeMatrix (v)

  Alias : `vander`

  Renvoie la matrice de Vandermonde.

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)

  Alias : `CREF` `ColumnReducedEchelonForm`

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

det

-     det (M)

  Alias : `Determinant`

  Renvoie le déterminant d'une matrice.

  Consultez Wikipedia ou Planetmath pour plus d'informations.

ref

-     ref (M)

  Alias : `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.

  Consultez Wikipedia ou Planetmath pour plus d'informations.

rref

-     rref (M)

  Alias : `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`.

  Consultez Wikipedia ou Planetmath pour plus d'informations.

### Combinatoire

Catalan

-     Catalan (n)

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

  Consultez Planetmath pour plus d'informations.

Combinaisons

-     Combinations (k,n)

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

DoubleFactorial

-     DoubleFactorial (n)

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

  Consultez Planetmath pour plus d'informations.

Factorial

-     Factorial (n)

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

  Consultez Planetmath pour plus d'informations.

FallingFactorial

-     FallingFactorial (n,k)

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

  Consultez Planetmath pour plus d'informations.

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

  Consultez Wikipedia ou Planetmath ou Mathworld pour plus d'informations.

FrobeniusNumber

-     FrobeniusNumber (v,param...)

  Calcule le nombre de Frobenius. C'est-à-dire calcule le plus petit nombre qui ne peut pas être obtenu comme une combinaison linéaire d'entiers non négatifs d'un vecteur donné d'entiers non négatifs. Le vecteur peut être fourni sous la forme de nombre séparés ou d'un seul vecteur. Tous les nombres fournis doivent avoir un PGCD de 1.

  Consultez Mathworld pour plus d'informations.

GaloisMatrix

-     GaloisMatrix (règle_de_combinaison)

  Matrice de Galois étant donnée la règle de combinaison linéaire (a_1*x_+...+a_n*x_n=x_(n+1)).

GreedyAlgorithm

-     FrobeniusNumber (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.

  Consultez Mathworld pour plus d'informations.

HarmonicNumber

-     HarmonicNumber (n,r)

  Alias : `HarmonicH`

  Nombre harmonique, le `n`-ième nombre harmonique d'ordre `r`.

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

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.

  La formule pour `Multinomial(a,b,c)` peut s'écrire sous la forme :

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

  En d'autres termes, si vous n'avez que deux éléments alors `Multinomial(a,b)` est la même chose que `Binomial(a+b,a)` ou `Binomial(a+b,b)`.

  Consultez Planetmath, Mathworld ou Wikipedia pour plus d'informations.

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.

  Par exemple, avec la fonction Combinations, vous devriez normalement écrire une boucle du style :

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

  Mais avec NextCombination, vous écrivez quelque chose comme cela :

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

  Consultez également Combinations.

Pascal

-     Pascal (i)

  Calcule le triangle de Pascal sous la forme d'une matrice. Cela renvoie une matrice `i`+1 par `i`+1 diagonale inférieure qui est le triangle de Pascal après `i` itérations.

  Consultez Planetmath pour plus d'informations.

Permutations

-     Permutations (k,n)

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

  Consultez Mathworld ou Wikipedia pour plus d'informations.

RisingFactorial

-     RisingFactorial (n,k)

  Alias : `Pochhammer`

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

  Consultez Planetmath pour plus d'informations.

StirlingNumberFirst

-     StirlingNumberFirst (n,m)

  Alias : `StirlingS1`

  Nombre de Stirling du premier type.

  Consultez Planetmath ou Mathworld pour plus d'informations.

StirlingNumberSecond

-     StirlingNumberSecond (n,m)

  Alias : `StirlingS2`

  Nombre de Stirling du second type.

  Consultez Planetmath ou Mathworld pour plus d'informations.

Subfactorial

-     Subfactorial (n)

  Sous-factorielle : n! multiplié par sum_{k=1}^n (-1)^k/k!.

Triangular

-     Triangular (nième)

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

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

nPr

-     nPr (n,r)

  Calcule le nombre de permutations de taille `r` de nombres compris entre 1 et `n`.

  Consultez Mathworld ou Wikipedia pour plus d'informations.

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

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

Derivative

-     Derivative (f,x0)

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

EvenPeriodicExtension

-     EvenPeriodicExtension (f,L)

  Renvoie une fonction qui est l'extension périodique paire de `f` de demi-période `L`. C'est-à-dire une fonction définie sur l'intervalle `[0,L]` étendue de manière à être paire sur `[-L,L]` puis rendue périodique de période `2*L`.

  Consultez aussi OddPeriodicExtension et PeriodicExtension.

FourierSeriesFunction

-     FourierSeriesFunction (a,b,L)

  Renvoie une fonction qui est la série de Fourier de coefficients donnés par les vecteurs `a` (cosinus) et `b` (sinus). Notez que `a@(1)` est le coefficient constant donc `a@(n)` se rapporte au terme en `cos(x*(n-1)*pi/L)` alors que `b@(n)` se rapporte au terme en `sin(x*n*pi/L)`. Il est possible que `a` ou `b` soit `null`.

  Consultez Wikipedia ou Mathworld pour plus d'informations.

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.

NumericalFourierSeriesCoefficients

-     NumericalFourierSeriesCoefficients (f,L,N)

  Renvoie un vecteur de vecteurs `[a,b]` où `a` sont les coefficients des cosinus et `b` ceux des sinus de la série de Fourier de la fonction `f` de demi-période `L` (définie sur l'intervalle `[-L,L]` et étendue de manière périodique), calculée numériquement jusqu'au `N`-ième harmonique. Les coefficients sont calculés par intégration numérique en utilisant la fonction `NumericalIntegral`.

  Consultez Wikipedia ou Mathworld pour plus d'informations.

NumericalFourierSeriesFunction

-     NumericalFourierSeriesFunction (f,L,N)

  Renvoie une fonction, qui est la série de Fourier de la fonction `f` de demi-période `L` (définie sur l'intervalle `[-L,L]` et étendue de manière périodique), calculée numériquement jusqu'au `N`-ième harmonique. C'est la série trigonométrique réelle composée de sinus et de cosinus. Les coefficients sont calculés par intégration numérique en utilisant la fonction `NumericalIntegral`.

  Consultez Wikipedia ou Mathworld pour plus d'informations.

NumericalFourierCosineSeriesCoefficients

-     NumericalFourierCosineSeriesCoefficients (f,L,N)

  Renvoie un vecteur des coefficients de la série de Fourier en cosinus de `f` de demi-période `L`. C'est-à-dire la fonction `f` définie sur l'intervalle `[0,L]` est étendue en la rendant périodique paire, puis la série de Fourier qui ne contient que des termes en cosinus, est calculée. La série est calculée jusqu'au `N`-ième harmonique. Les coefficients sont calculés par intégration numérique en utilisant la fonction `NumericalIntegral`. Notez que `a@(1)` est le coefficient constant, donc `a@(n)` se rapporte au terme en `cos(x*(n-1)*pi/L)`.

  Consultez Wikipedia ou Mathworld pour plus d'informations.

NumericalFourierCosineSeriesFunction

-     NumericalFourierCosineSeriesFunction (f,L,N)

  Renvoie une fonction qui est la série de Fourier en cosinus de `f` de demi-période `L`. C'est-à-dire la fonction `f` définie sur l'intervalle `[0,L]` est étendue en la rendant périodique paire, puis la série de Fourier qui ne contient que des termes en cosinus, est calculée. La série est calculée jusqu'au `N`-ième harmonique. Les coefficients sont calculés par intégration numérique en utilisant la fonction `NumericalIntegral`.

  Consultez Wikipedia ou Mathworld pour plus d'informations.

NumericalFourierSineSeriesCoefficients

-     NumericalFourierSineSeriesCoefficients (f,L,N)

  Renvoie un vecteur des coefficients de la série de Fourier en sinus de `f` de demi-période `L`. C'est-à-dire la fonction `f` définie sur l'intervalle `[0,L]` est étendue en la rendant périodique impaire, puis la série de Fourier qui ne contient que des termes en sinus, est calculée. La série est calculée jusqu'au `N`-ième harmonique. Les coefficients sont calculés par intégration numérique en utilisant la fonction `NumericalIntegral`.

  Consultez Wikipedia ou Mathworld pour plus d'informations.

NumericalFourierSineSeriesFunction

-     NumericalFourierSineSeriesFunction (f,L,N)

  Renvoie une fonction qui est la série de Fourier en sinus de `f` de demi-période `L`. C'est-à-dire la fonction `f` définie sur l'intervalle `[0,L]` est étendue en la rendant périodique impaire, puis la série de Fourier qui ne contient que des termes en sinus, est calculée. La série est calculée jusqu'au `N`-ième harmonique. Les coefficients sont calculés par intégration numérique en utilisant la fonction `NumericalIntegral`.

  Consultez Wikipedia ou Mathworld pour plus d'informations.

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)

  Renvoie une fonction qui est l'extension périodique impaire de `f` de demi-période `L`. C'est-à-dire une fonction définie sur l'intervalle `[0,L]` étendue de manière à être impaire sur `[-L,L]` puis rendue périodique de période `2*L`.

  Consultez aussi EvenPeriodicExtension et PeriodicExtension.

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)

  Renvoie une fonction qui est l'extension périodique de `f` définie sur l'intervalle `[a,b]` et de période `b-a`.

  Consultez également OddPeriodicExtension et EvenPeriodicExtension.

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)

  Alias : `Arg` `arg`

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

DirichletKernel

-     DirichletKernel (n,t)

  Calcul le noyau de Dirichlet d'ordre 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.

  Consultez Planetmath pour plus d'informations.

FejerKernel

-     FejerKernel (n,t)

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

  Consultez Planetmath pour plus d'informations.

GammaFunction

-     GammaFunction (x)

  Alias : `Gamma`

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

  Consultez Planetmath pour plus d'informations.

KroneckerDelta

-     KroneckerDelta (v)

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

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.

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Planetmath pour plus d'informations.

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

  Consultez Planetmath pour plus d'informations.

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.

  Consultez Wikipedia pour plus d'informations.

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.

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

  Consultez Planetmath, Mathworld ou Wikipedia pour plus d'informations.

EulersMethod

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

  Utilise la méthode classique d'Euler 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.

  Consultez Mathworld ou Wikipedia pour plus d'informations.

EulersMethodFull

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

  Utilise la méthode classique d'Euler pour résoudre numériquement y'=f(x,y) avec les valeurs initiales `x0`, `y0` allant vers `x1` avec `n` incréments, renvoie une matrice 2 par `n+1` contenant les valeurs de `x` et `y` (approprié pour un usage avec LinePlotDrawLine).

  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.

  Consultez Mathworld ou Wikipedia pour plus d'informations.

FindRootBisection

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

  Cherche la racine d'une fonction en utilisant la méthode de dichotomie. `TOL` est la tolérance permise et `N` est la limite du nombre d'itérations réalisées, 0 signifiant aucune 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.

FindRootFalsePosition

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

  Cherche la racine d'une fonction en utilisant la méthode de la fausse position. `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.

FindRootMullersMethod

-     FindRootMullersMethod (f,x1,x2,x3,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)

  Cherche la racine d'une fonction en utilisant la méthode de la sécante. `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.

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.

  Consultez Planetmath ou Mathworld pour plus d'informations.

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.

  Consultez Planetmath, Mathworld ou Wikipedia pour plus d'informations.

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.

  Consultez Mathworld ou Wikipedia pour plus d'informations.

RungeKuttaFull

-     RungeKuttaFull (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 une matrice 2 par `n+1` contenant les valeurs de `x` et `y` (approprié pour un usage avec LinePlotDrawLine).

  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.

  Consultez Mathworld ou Wikipedia pour plus d'informations.

### Statistiques

Average

-     Average (m)

  Alias : `average` `Mean` `mean`

  Calcule la moyenne de toute une matrice.

  Consultez Mathworld pour plus d'informations.

GaussDistribution

-     GaussDistribution (x,sigma)

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

  Consultez Mathworld pour plus d'informations.

GaussFunction

-     GaussFunction (x,sigma)

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

  Consultez Mathworld pour plus d'informations.

Median

-     Median (m)

  Alias : `median`

  Calcule la médiane de toute une matrice.

  Consultez Mathworld pour plus d'informations.

PopulationStandardDeviation

-     PopulationStandardDeviation (m)

  Alias : `stdevp`

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

RowAverage

-     RowAverage (m)

  Alias : `RowMean`

  Calcule la moyenne de chaque ligne d'une matrice.

  Consultez Mathworld pour plus d'informations.

RowMedian

-     RowMedian (m)

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

  Consultez Mathworld pour plus d'informations.

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

  Consultez Planetmath pour plus d'informations.

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)

  Utilise la méthode de Newton sur un polynôme pour essayer de trouver une racine, s'arrête après deux valeurs successives égales, à epsilon près, ou après maxn essais (renvoie alors `null`).

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

MacaulayLowerOperator

-     MacaulayLowerOperator (c,d)

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

MacaulayRep

-     MacaulayRep (c,d)

  Return the dth Macaulay representation of a positive integer c.

### Divers

ASCIIToString

-     ASCIIToString (vec)

  Convertit un vecteur de valeurs ASCII en chaîne.

AlphabetToString

-     AlphabetToString (vec,alphabet)

  Convertit un vecteur d'indices en chaîne de caractères. Les indices correspondent à la position dans la chaîne `alphabet`, en commençant à zéro.

StringToASCII

-     StringToASCII (chaîne)

  Convertit une chaîne en vecteur de valeurs ASCII.

StringToAlphabet

-     StringToAlphabet (chaîne,alphabet)

  Convertit une `chaîne` de caractères en un vecteur d'indices correspondant à la position dans la chaîne `alphabet` (en commençant à zéro). Lorsque le caractère n'est pas dans l'`alphabet`, l'indice est -1.

### Calcul symbolique

SymbolicDerivative

-     SymbolicDerivative (f)

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

  Exemples :

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

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

SymbolicNthDerivative

-     SymbolicNthDerivative (f,n)

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

SymbolicNthDerivativeTry

-     SymbolicNthDerivativeTry (f,n)

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

SymbolicTaylorApproximationFunction

-     SymbolicTaylorApproximationFunction (f,x0,n)

  Essaie de construire la fonction approximation de Taylor autour de x0 au nième degré (consultez `SymbolicDerivative`).

### Tracé de graphiques

LinePlot

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

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

  Trace la courbe de une à dix fonctions cartésiennes. Les premiers arguments, jusqu'à dix au plus, sont les fonctions à tracer. Vous pouvez ensuite rajouter quatre paramètres `x1`, `x2`, `y1` et `y2` pour spécifier les limites de la fenêtre de tracé. Si les limites de la fenêtre de tracé ne sont pas indiquées alors les limites définies par `LinePlotWindow` sont appliquées.

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

  Exemples :

      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.

LinePlotDrawLine

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

      LinePlotDrawLine (v,...)

  Trace une ligne du point `x1`, `y1` au point `x2`, `y2`. Les points `x1`, `y1`, `x2`, `y2` peuvent être remplacés par une matrice `n` par 2 pour tracer une polyligne.

  Des paramètres supplémentaires peuvent être ajoutés pour spécifier la couleur de la ligne, des flèches et la zone de tracé. Vous pouvez faire cela en ajoutant une chaîne `"color"`, `"thickness"`, `"window"` ou `"arrow"` et ensuite, respectivement, la chaîne de couleur (en anglais), l'épaisseur sous la forme d'un entier, la fenêtre sous la forme d'un vecteur à 4 éléments et pour la flèche soit `"origin"`, `"end"`, `"both"` ou `"none"`. Pour `"window"`, vous pouvez indiquer `"fit"` plutôt qu'un vecteur et dans ce cas, l'intervalle x est défini de manière précise et l'intervalle y est défini avec une bordure de cinq pour cent autour de la ligne. Finalement, la légende peut être spécifiée en ajoutant `"legend"` et la chaîne contenant la légende.

  Exemples :

      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(EulersMethodFull(`(x,y)=y,0,3,100),"color","blue","legend","La solution")

LinePlotParametric

-     LinePlotParametric (xfonc,yfonc,...)

      LinePlotParametric (xfonc,yfonc,t1,t2,tinc)

      LinePlotParametric (xfonc,yfonc,t1,t2,tinc,x1,x2,y1,y2)

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

  Si les limites de la fenêtre de tracé ne sont pas indiquées alors les limites définies par `LinePlotWindow` sont appliquées.

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

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

  Si les limites de la fenêtre de tracé ne sont pas indiquées alors les limites définies par `LinePlotWindow` sont appliquées.

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

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.

  Exemples :

      genius> Slopefield(`(x,y)=sin(x-y),-5,5,-5,5)

SurfacePlot

-     SurfacePlot (fonc)

      SurfacePlot (fonc,x1,x2,y1,y2,z1,z2)

  Trace une surface, dont la fonction prend comme arguments deux nombres ou bien un nombre complexe. En premier vient la fonction puis en option les limites 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`). Genius ne peut tracer qu'une seule surface à la fois.

  Exemples :

      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)

VectorfieldClearSolutions

-     VectorfieldClearSolutions ()

  Efface les solutions dessinées par la fonction `VectorfieldDrawSolution`.

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.

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.

  Exemples :

      genius> VectorfieldPlot(`(x,y)=x^2-y, `(x,y)=y^2-x, -1, 1, -1, 1)

## Exemple de programmes en GEL

Voici une fonction qui calcule des factorielles :

    function f(x) = if x <= 1 then 1 else (f(x-1)*x)

Avec des indentations, cela devient :

    function f(x) = (
      if x <= 1 then
        1
      else
        (f(x-1)*x)
    )

C'est un portage direct de la fonction factorielle de la page de manuel de bc. La syntaxe semble similaire à celle de bc mais différente par le fait que dans GEL, la dernière expression est celle qui est renvoyée. En utilisant la fonction `return` à la place, cela donnerait :

    function f(x) = (
      if (x <= 1) then return (1);
      return (f(x-1) * x)
    )

La façon, de loin la plus facile, de définir une fonction factorielle serait d'utiliser la boucle de produit de la manière suivante. Ce n'est pas seulement la plus courte et la plus rapide mais aussi probablement la version la plus lisible.

    function f(x) = prod k=1 to x do k

Voici un exemple plus conséquent qui redéfinit essentiellement la fonction interne `ref` pour calculer la matrice échelonnée en lignes d'une matrice. La fonction `ref` est intégrée et beaucoup plus rapide mais cet exemple démontre certaines des fonctionnalités plus complexes de GEL.

    # Calculate the row-echelon form of a matrix
    function MyOwnREF(m) = (
      if not IsMatrix(m) or not IsValueOnly(m) then
        (error("ref: 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

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

### 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 genius-gel-variables à propos de l'évaluation et genius-gel-function-parameters pour une liste des réglages qui peuvent être modifiés de cette façon.

Par exemple, vous pouvez paramétrer le nombre maximum de chiffres pour l'affichage d'un résultat à 12 en saisissant :

    MaxDigits = 12

### Sortie

Nombre maximum de chiffres à afficher

- Le nombre maximum de chiffres dans un résultat (`MaxDigits`)

Résultats en nombres flottants

- Si les résultats doivent être toujours affichés sous la forme de nombres flottants (`ResultsAsFloats`)

Nombres flottants en notation scientifique

- Si les nombres flottants doivent être affichés en notation scientifique (`ScientificNotation`)

Toujours afficher les expressions complètes

- Si l'expression complète doit être affichée pour les valeurs renvoyées non numériques (plus longues qu'une ligne) (`FullExpressions`)

Utiliser les fractions mixtes

- Si les fractions doivent être affichées comme des fractions mixtes telles que « 1 1/3 » plutôt que « 4/3 ». (`MixedFractions`)

Afficher 0.0 lorsqu'un nombre flottant est inférieur à 10^-x (0=ne jamais arrondir)

- Comment arrondir la sortie. Mais seulement lorsque d'autres nombres autour sont grands. Consultez la documentation du paramètre `OutputChopExponent`.

Arrondir les nombres uniquement si un autre nombre est plus grand que 10^-x

- Quand arrondir la sortie. C'est configuré par le paramètre `OutputchopWhenexponent`. Consultez la documentation du paramètre `OutputChopExponenthopwhenexponent`.

Se souvenir des paramètres de sortie d'une session à l'autre

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

Afficher les erreurs dans une boîte de dialogue

- If set the errors will be displayed in a separate dialog, if unset the errors will be printed on the console.

Afficher les messages d'informations dans une boîte de dialogue

- If set the information messages will be displayed in a separate dialog, if unset the information messages will be printed on the console.

Nombre maximum d'erreurs à afficher

- Le nombre maximum d'erreurs à afficher pour une évaluation (`MaxErrors`). Si vous paramétrez à 0 alors toutes les erreurs sont toujours renvoyées. Habituellement si certaines boucles provoquent beaucoup d'erreurs alors il est probable que vous ne serez pas capable de donner un sens à plus de quelques unes d'entre elles. Ainsi voir une longue liste d'erreurs n'apporte pas généralement grand chose.

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 genius-gel-function-parameters.

`IntegerOutputBase`

- La base utilisée pour afficher les entiers.

`OutputStyle`

- Une chaîne, qui peut être `"normal"`, `"latex"`, `"mathml"` ou `"troff"` et qui modifie la manière dont les matrices (et peut-être d'autres trucs) sont affichées. Cela peut être utile pour copier/coller vers des documents. Le style normal est le style d'affichage par défaut de l'Outil de maths Genius. Les autres styles sont utiles pour saisir en LaTeX, MathML (XML) ou Troff.

### Précision

Précision des nombres en virgule flottante

- La précision des nombres en virgule flottante en bits (`FloatPrecision`). Notez que lorsque vous modifiez ce paramètre, seules les nouvelles quantités calculées sont affectées. Les anciennes valeurs enregistrées dans des variables restent toujours avec la même précision et si vous voulez qu'elles soient plus précises, vous devez les recalculer. Les exceptions sont les constantes du système telles que `pi` ou `e`.

Se souvenir de la précision choisie d'une session à l'autre

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

Lignes d'historique

- Nombre de lignes d'historique dans le terminal.

Police

- La police à utiliser dans le terminal.

Noir sur blanc

- Si vous utilisez du noir sur blanc dans le terminal.

Curseur clignotant

- 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

Nombre maximum de nœuds à allouer

- De manière interne, toutes les données sont placées dans des nœuds en mémoire. Ce paramètre fournit une limite sur le nombre maximum de nœuds à allouer pour les calculs. Cela évite le problème d'une saturation de mémoire si vous faites quelque chose par erreur qui utilise trop de mémoire, telle qu'un calcul récursif sans fin. Cela pourrait ralentir votre ordinateur et rendre difficile même l'interruption du programme.

  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, procédez comme indiqué sur la page de réactions sur GNOME.

Ce programme est distribué au titre des clauses de la Licence Publique Générale GNU (GPL), telle que publiée par la Free Software Foundation ; soit la version 2 de la licence, ou (à votre discrétion) une version ultérieure quelconque. Une copie de cette licence peut être trouvée à ce lien, ou dans le fichier COPYING inclus avec le code source du programme.

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