root/haypocalc/fct_fr.ini

/*****************************************************************************
 * Description et exemples des fonctions de HaypoCALC
 *****************************************************************************
 * Format du fichier *
 *********************
 *
 * - Chaque partie est introduite par une catégorie écrite entre crochets.
 *   Exemple : "[ Général ]".
 * - Chaque fonction est introduite par son nom internationnal entre accolades.
 *   Exemple: "{COS}".
 *
 * Caractères spéciaux :
 * '\n' = retour à la ligne
 * '\t' = tabulation
 * '\\' = anti-slash '\'
 * '\/' = slash '/'
 *
 * Commentaires :
 * o "//" : Tout ce qui suit jusqu'à la fin de la ligne
 * o "/ *" et "* /" : Délimite des commentaires multi-ligne (sans espace!)
 *
 *****************************************************************************
 * Champs d'une fonction *
 *************************
 *
 * DES  : Description courte (ce que réalise la fonction). Utilisez %P?% où ?
 *        est le numéro du paramètre pour obtenir le nom d'un paramètre.
 * EXPL : Exemple(s), utilisez "%NOM%" pour obtenir le nom de la fonction.
 ****************************************************************************/

//--------------------
// Fonctions générales
//--------------------
[Général]
 {LISP}
 DES=Convertit l'expression %P1% en expression LISP sous forme d'une chaine de
    = caractère.\n
    =Utilisez la fonction 'EvaluePas' pour éviter les simplifications.
 EXPL=%NOM%(EvaluePas(1+2))=(+ 1 2)\n
     =%NOM%(cos(x^2)/7)=(/ (cos (^ x 2)) 7)\n
     =%NOM%($1) renvoie le résultat précédant au format LISP.

 {MINIMUM}
 DES=Minimum du couple {%P1%, %P2%}, équivalent à Si (x<=y) x sinon y
 EXPL=%NOM%(-2, 7) renvoie -2\n
     =%NOM%("chat", "chien") renvoie "chat"

 {MAXIMUM}
 DES=Maximum du couple {%P1%, %P2%}, équivalent à Si (x<=y) y sinon x
 EXPL=%NOM%(-2, 7) renvoie 7\n
     =%NOM%("chat", "chien") renvoie "chien"

//--------------
// Console texte
//--------------
[Console texte]

 {GET_KEY}
 DES=Lit une touche au clavier, attend si le tampon du clavier est vide.\n
    =Voyez aussi la fonction Touche().

 {KEY_CODE}
 DES=Code de la touche identifiée par la chaîne %P1%.
 EXPL=%NOM%("ENTER") renvoie le code de la touche "entrée".\n
     =%NOM%("UP") renvoie le code de la touche "haut".

 {CLEAR_CONSOLE}
 DES=Efface le contenu de la console texte et place le curseur
    = à la position (1,1).

 {CONSOLE_SIZE}
 DES=Taille de la console {larg,haut} en caractères.

 {WHERE_XY}
 DES=Coordonnées du curseur texte {x,y}.
    = Le coin haut-gauche ayant les coordonnées (1,1).

 {GOTO_XY}
 DES=Déplace le curseur texte en (x,y). Le coin haut-gauche ayant
    = les coordonnées (1,1).

//--------------------
// Fonctions traitant du signe d'une expression
//--------------------
[Signe]
 {OPPOSITE}
 DES=Renvoie l'opposé de %P1%.
 EXPL=%NOM%(4)=-4.\n
     =%NOM%(x)=-x.

 {ABS}
 DES=Valeur absolue de l'expression %P1%.
 EXPL=%NOM%(-4)=4\n
     =%NOM%(Oppose(x))=x

 {SIGN}
 DES=Signe de %P1% : renvoie (-1) si %P1% est négatif, 1 s'il est positif,
    = ou PlusMoins(1) si on ne peut pas le déterminer (pour zéro par exemple).
 EXPL=%NOM%(-4) -> -1\n
     =%NOM%(7.2) -> 1\n
     =%NOM%(0) -> PlusMoins(1)\n
     =%NOM%(Abs(x)) -> 1\n
     =%NOM%(-x) -> -(%NOM%(x))

 {MORE_LESS}
 DES=Plus ou moins %P1%. %NOM%(1) est le signe de 0.

//--------------------
// Fonctions traitant du (pseudo) hasard
//--------------------
[Hasard]
 {RANDOM}
 DES=Renvoie un élément aléatoire de type '%P1%'.\n
    =o %NOM%("BOOL") renvoie Vrai ou Faux.\n
    =o %NOM%("ENTIER") renvoie un nombre entier compris dans
    =  [entier_min;entier_max].\n
    =o %NOM%("REEL") renvoie un nombre réel compris dans [0;1[.\n
    =o %NOM%("CST") renvoie une constante.\n
    =o %NOM%("OP") renvoie un opérateur (sous forme d'une chaîne de
    = caractères.\n
    =o %NOM%("FCT") renvoie une fonction (sous forme d'une chaîne de
    = caractères.

 {RANDOM_INT}
 DES=Génère un nombre entier pseudo-aléatoire compris dans l'intervalle
    = [%P1%, %P2%].
 EXPL='%NOM%(1,6)' simule un lancé de dé (face numérotée de 1 à 6)

 {RANDOM_SEED}
 DES=Initialise le générateur de nombre pseudo-aléatoire.
 EXPL='%NOM%(4); Seq(EntierAleat(13,25),i,1,6);'
     = renverra toujours la même suite.

//-------------------------
// Fonctions d'arithmétique
//-------------------------
[Arithmétique]
 {MODULO_REAL}
 DES=Calcule %P1% modulo %P2%, avec %P1% et %P2%: nombres réels. C'est-à-dire
    = le reste dans la division réelle de %P1% par %P2%.
 EXPL=Approx(%NOM%(7.2,2$pi)) renvoie 0.916...

 {GCD}
 DES=Plus grand commun diviseur de %P1% et de %P2%.
 EXPL=%NOM%(28,70) renvoie 14.\n
     =Effectivement 28=2^2*7, 70=2*5*7 et 14=2*7.\n
     =(on prend tous les facteurs premiers communs et l'exposant
     = le plus faible)

 {LCM}
 DES=Plus petit commun multiple de %P1% et %P2%.
 EXPL=%NOM%(28,70) renvoie 140. Effectivement 28=2^2*7,
     = 70=2*5*7 et 140=2^2*5*7.
     =\n(on prend tous les facteurs premiers et l'exposant le plus élevé)

 {FACTORIAL}
 DES=Calcule le factoriel du nombre %P1% (1*2*3*...*%P1%).
 EXPL=0! vaut 1\n
     =2! vaut 2\n
     =5! vaut 120 (=1*2*3*4*5)

 {BASEN}
 DES=Convertit le nombre %P1% dans la base %P2% (comprise entre 2 et 36).
 EXPL=%NOM%(6,2) renvoie "110"\n
     =%NOM%(10,16) renvoie "A"

 {UNBASEN}
 DES=Convertit le nombre %P1% (exprimé sous forme d'une chaine de caractère)
    = de la base %P2% vers la base décimale.

 {FLOOR}
 DES=Renvoie le plus grand nombre entier inférieur au nombre %P1%.\n
    =(renvoie %P1% si c'est un nombre entier)
 EXPL=%NOM%(-3.4) renvoie -4.\n
     =%NOM%(0.1) renvoie 0.\n
     =%NOM%(5.99) renvoie 5.\n
     =%NOM%(7) renvoie 7.

 {CEIL}
 DES=Renvoie le plus petit nombre entier supérieur au nombre %P1%.\n
    =(renvoie %P1% si c'est un nombre entier).
 EXPL=%NOM%(-3.4) renvoie -3.\n
     =%NOM%(0.1) renvoie 1.\n
     =%NOM%(5.99) renvoie 6.\n
     =%NOM%(7) renvoie 7.

 {INT_PART}
 DES=Renvoie la partie entière du nombre %P1%.
 EXPL=%NOM%(-3.4) renvoie -3.\n
     =%NOM%(0.1) renvoie 0.\n
     =%NOM%(5.99) renvoie 5.

 {FRACT_PART}
 DES=Renvoie la partie fractionnaire du nombre %P1% (négative si le nombre
    = est négatif).
 EXPL=%NOM%(-3.4) renvoie -0.4\n
     =%NOM%(0.1) renvoie 0\n
     =%NOM%(5.99) renvoie 0.99

 {ROUND}
 DES=Arrondit le nombre %P1% à l'entier le plus proche.\n
    =Note: Identique à ChangeType(%P1%,"INT")
 EXPL=%NOM%(-3.2) renvoie -3\n
     =%NOM%(-3.7) renvoie -4\n
     =%NOM%(1.9) renvoie 2

 {TRUNC}
 DES=Tronque le nombre %P1% à %P2% décimales, %P2% peut-être négatif.
    = Dans ce là, les chiffres en partant de l'unité vers le chiffre de plus
    = forte valeur sont mis à zéro.\n
    =Le résultat est arrondit à la valeur la plus proche.
 EXPL=%NOM%(1.40576,3) renvoie 1.406\n
     =%NOM%(3.4,0) renvoie 3\n
     =%NOM%(3.6,0) renvoie 4\n
     =%NOM%(747,-2) renvoie 700

 {NBR_ARR}
 DES=Nombre d'arrangement de %P1% éléments parmis %P2% éléments.\n
    =%NOM%(%P1%,%P2%)=(%P1%!)/(%P1%-%P2%)!
 EXPL=%NOM%(5, 3) renvoie 60\n
     =%NOM%(7, 4) renvoie 840

 {NBR_COMB}
 DES=Nombre de combinaisons de %P1% éléments parmis %P2% éléments.\n
    =%NOM%(%P1%,%P2%)=(%P1%!)/((%P1%-%P2%)!*(%P2%!))
 EXPL=%NOM%(5, 3) renvoie 10\n
     =%NOM%(7, 4) renvoie 35

 {BEZOUT}
 DES=Calcule le coefficient de Bezout (u,v) tels que
    = %P1%*u+%P2%*v=Pgcd(%P1%,%P2%). Renvoie le résultat sous forme de
    = la liste : {u,v,Pgcd(%P1%,%P2%)}.\n
    =Remarque: On appelle ça également le calcul du Pgcd étendu.
 EXPL=%NOM%(2,3) renvoie {-1,1,1}.

 {FIBONACCI}
 DES=Renvoie le %P1%-ième terme de la suite de Fibonnaci.\n
    =La suite est définie par : U(0)=0, U(1)=1, U(n)=U(n-1)+U(n-2).
 EXPL=%NOM%(0) renvoie 0.\n
     =%NOM%(1) renvoie 1.\n
     =%NOM%(2) renvoie 1.\n
     =%NOM%(10) renvoie 55.\n
     =On peut définir 'phi(n)=%NOM%(n)/%NOM%(n-1)' et vérifier que quand
     = n tend vers l'infini, phi tend vers (1+Racine(5))/2.

 {INT_DIV}
 DES=Division entière de %P1% par %P2%.

 {DIGIT_NB}
 DES=Nombre de chiffre décimaux de la partie entière du nombre (entier ou réel)
    = %P1%.
 EXPL=%NOM%(-123) renvoie 3\n
     =%NOM%(0.478) renvoie 1\n
     =%NOM%(0) renvoie 1

//--------------------------------------------------------
// Fonctions d'arithmétique relatives aux nombres premiers
//--------------------------------------------------------

[Nombre premier]
 {IS_PRIME}
 DES=Détermine si le nombre %P1% est premier ou non.
 EXPL='%NOM%(7)' renvoie 'Vrai'. Effectivement le nombre 7 n'a que deux
     = diviseurs, 1 et lui-même.\n
     =Par contre '%NOM%(15)' renvoie 'Faux'. C'est correct car 15=3*5.

 {NEXT_PRIME}
 DES=Cherche le nombre premier suivant %P1%.

 {PREV_PRIME}
 DES=Cherche le nombre premier précédent %P1%, renvoie FAUX s'il n'y a pas
    = (le plus petit nombre premier est 2).
 EXPL=%NOM%(10) renvoie 7\n
     =%NOM%(3) renvoie 2\n
     =%NOM%(2) renvoie FAUX

 {FACTOR}
 DES=Factorise le nombre %P1% en produit de facteurs premiers, renvoie une
    = liste de couple {facteur,exposant}.
 EXPL=%NOM%(14) renvoie {{2,1},{7,1}}\n
     =%NOM%(1960) renvoie {{2,3},{5,1},{7,2}}

 {DIVISOR_LIST}
 DES=Liste des diviseurs du nombre entier %P1%.
 EXPL=%NOM%(-10) renvoie {-10,-5,-2,-1,1,2,5,10}\n
     =%NOM%(3) renvoie {1,3}\n
     =%NOM%(14) renvoie {1,2,7,14}

 {LUCAS}
 DES=Test de primauté pour le nombre 2^%P1%-1.\n
    =Valeurs de %P1% tel que le test renvoie vrai : 2, 3, 5, 7, 13, 17,
    = 19, 31, 61, 89, 107, 127, 521, 607, ...
 EXPL=%NOM%(1) renvoie FAUX (2^1-1 = 1 n'est pas premier)\n
     =%NOM%(31) renvoie VRAI (2^31-1 est premier)

//---------------------------
// Fonctions de trigonométrie
//---------------------------

[Trigonométrie]
 {COS}
 DES=Calcule le cosinus de l'angle %P1% exprimé en radian.
 EXPL=%NOM%(0) renvoie 1.\n
     =%NOM%($pi/2) renvoie 0.

 {SIN}
 DES=Calcule le sinus de l'angle %P1% exprimé en radian.
 EXPL=%NOM%(0) renvoie 0.\n
     =%NOM%($pi/2) renvoie 1.

 {TAN}
 DES=Calcule la tangente de l'angle %P1% exprimé en radian.
 EXPL=%NOM%(0) renvoie 0.\n
     =%NOM%($pi/4) renvoie 1.

 {ARCCOS}
 DES=Calcule l'arc-cosinus de %P1% où -1<=%P1%<=1.
 EXPL=%NOM%(1) renvoie 0.\n
     =%NOM%(0) renvoie $pi/2.

 {ARCSIN}
 DES=Calcule l'arc-sinus de %P1% où -1<=%P1%<=1.
 EXPL=%NOM%(0) renvoie 0.\n
     =%NOM%(1) renvoie $pi/2.

 {ARCTAN}
 DES=Calcule l'arctangente de %P1%.
 EXPL=%NOM%(0) renvoie 0.\n
     =%NOM%(1) renvoie $pi/4.

//---------------------------
// Fonctions de calcul formel
//---------------------------

[Calcul formel]
 {DERIVATE}
 DES=Calcule la fonction dérivé de la fonction %P1% par rapport
    = à la variable %P2%.

 {DERIVATEN}
 DES=Calcule la dérivé %P2%-ième de la fonction %P1% par rapport
    = à la variable %P3%.

 {TAYLOR}
 DES=Calcule le développement limité de la fonction %P1% au point %P3%
    = jusqu'à l'ordre %P2% par rapport à la variable %P4%.\n
    =C'est le polynôme approchant la fonction %P1% pour des valeurs proches
    = de %P3%. Il permet d'évaluer %P1% pour des valeurs proches de %P3%, et
    = d'étudier la limite au point %P3%.
 EXPL='f(x)=%NOM%(Cos(x),4,0,x)' renvoie 'x^4/24-x^2/2+1'.\n
     =Cos(0.123)=0.992445032... et f(0.123)=0.992445036..., le résultat est
     = correct pour 8 décimales !!!

 {EVALUATE}
 DES=Evalue l'expression '%P1%' en remplaçant la variable '%P2%' par '%P3%'.\n
    =Cette fonction est également très pratique pour faire un changement
    = de variable.
 EXPL=- %NOM%(x^2+1,x,3) -> 10\n
     =- %NOM%(Ln(x^2),x,1/u) -> -(2*Ln(u))

 {EQUIVALENT}
 DES=Calcule la fonction équivalente de la fonction %P1% au point %P2% par
    = rapport à la variable %P3%.\n
    =La limite de %P1%(%P3%)/g(%P3%) quand %P3% tend vers %P2% doit valoir 1
    = (la fonction g(%P3%) étant la fonction équivalante).\n
    =(c'est en fait le premier terme non nul du développement limité)
 EXPL='%NOM%(Sin(x),0,x)' renvoie 'x'.\n
     ='%NOM%(1-Cos(x),0,x)' renvoie 'x^2/2'.

 {SUM}
 DES=Somme des termes %P1%(%P2%) en faisant varier %P2% de %P3% à %P4%.
 EXPL=%NOM%(i,i,0,10) renvoie 55

 {PRODUCT}
 DES=Produit des termes %P1%(%P2%) en faisant varier %P2% de %P3% à %P4%.
 EXPL=%NOM%(n,n,1,10) renvoie 10!

 {PART}
 DES=Partitionne l'expression %P1% en une liste d'éléments :\n
    =[0] Type de élément 1 de la liste\n
    =[1] Element central : les opérateurs et les fonctions sont convertis en
    = une chaîne de caractère. Le nom des fonctions est le
    = nom internationnal (en majuscule).\n
    =[2..2+n] : Les n paramètre(s)
 EXPL=- %NOM%(0) -> {"INT", 0}\n
     =- %NOM%(a+7) -> {"OP", "+", a, 7}\n
     =- %NOM%(Pgcd(a,b)) -> {"FCT", "GCD", a, b}\n
     =- %NOM%({a,b,c} -> {"LIST", a, b, c}\n
     =- %NOM%(EvaluePas({instr1;instr2;})) -> {"BLOC",instr1,instr2}

//--------------------
// Fonctions puissance
//--------------------
[Puissance]
 {EXP}
 DES=Calcule l'exponentiel de %P1%.
 EXPL=%NOM%(0) renvoie 1.\n
     =%NOM%(1) renvoie la constante 'e' ($e) ou 2.7182818...\n
     =%NOM%(2*Ln(x)) renvoie x^2

 {LOG2}
 DES=Calcule le logarithme naturel de %P1%.\n
    =Les propriétés Ln(x*y)=Ln(x)+Ln(y) et Ln(x^n)=n*Ln(x) sont prises
    = en comptes.
 EXPL=%NOM%(1) renvoie 0.\n
     =%NOM%(2) renvoie 0.693147...\n
     =Exact(%NOM%(2*n^10)) renvoie 10*%NOM%(n)+%NOM%(2)

 {LOG10}
 DES=Calcule le logarithme décimal de %P1%.
 EXPL=%NOM%(1) renvoie 0.\n
     =%NOM%(2) renvoie 0.30103...\n
     =%NOM%(10) renvoie 1.

 {SQRT}
 DES=Calcule la racine carrée de %P1%.\n
    =(le nombre qui élevé au carré donne %P1%)
 EXPL=%NOM%(0) renvoie 0.\n
     =%NOM%(2) renvoie 1.41421...

 {NROOT}
 DES=Calcule la racine carrée %P2%-ième de %P1%.\n
    =Ce qui est équivalent à %P1%^(1/%P2%).
 EXPL=%NOM%(125, 3) renvoie 5.

//---------------------------------
// Gestion des chaînes de caractère
//---------------------------------

[Chaîne de caractères]
 {IS_ALPHA}
 DES=Dit si le caractère %P1% représente une lettre, ou non.
    =Les lettres sont les caractères abcde...xyz, et ABCDE...XYZ.
 EXPL=%NOM%("a") renvoie VRAI.\n
     =%NOM%("salut") renvoie FALSE.\n
     =%NOM%("3") renvoie FALSE.

 {IS_DIGIT}
 DES=Dit si le caractère %P1% représente un chiffre, ou non.
 EXPL=%NOM%("7") renvoie VRAI.\n
     =%NOM%("397") renvoie FALSE.\n
     =%NOM%("a") renvoie FALSE.

 {STRING}
 DES=Traduit l'expression %P1% en une chaine de caractère.\n
    =(fonction inverse de la fonction 'Expr')
 EXPL='%NOM%(x)' renvoie '"x"'.

 {EXPRESSION}
 DES=Traduit la chaine de caractère %P1% en expression.\n
    =(fonction inverse de la fonction 'String')\n
    =Astuce: Vous pouvez utiliser le caractère '#' à la place de '%NOM%'.
 EXPL='%NOM%("1+2")' ou '#"1+2"' renvoie '3'.

 {ORD}
 DES=Renvoie le code ASCII du caractère %P1%.
 EXPL=%NOM%(' ') renvoie 32\n
     =%NOM%('A') renvoie 65

 {ASCII}
 DES=Renvoie le %P1%-ième caractère de la table ASCII.\n
    =Seul les caractères compris dans [32;128] sont gérés.
 EXPL=%NOM%(32) renvoie ' '\n
     =%NOM%(65) renvoie 'A'

 {FRENCH}
 DES=Traduit une expression en français, en particulier les nombres.
 EXPL='%NOM%("123")' renvoie "cent vingt trois".

//----------------------------
// Fonctions gérant les listes
//----------------------------

[Liste]
 {NEW_LIST}
 DES=Crée une liste contenant %P1% fois la valeur %P2%.
 EXPL=%NOM%(3) renvoie {0,0,0}\n
     =%NOM%(2,47) renvoie {47,47}

 {DIMENSION}
 DES=Renvoie la dimension de %P1% :
    = renvoie le nombre d'éléments si c'est une liste,
    = ou le nombre de caractères si c'est une chaîne de caractères.
 EXPL=%NOM%({}) renvoie 0.\n
     =%NOM%({1,2,3}) renvoie 3.\n
     =%NOM%("a") renvoie 1.\n
     =%NOM%("123") renvoie 3.

 {LIST_SUM}
 DES=Calcule la somme des éléments de la liste définie.
 EXPL=%NOM%({}) renvoie 0.\n
     =%NOM%({1,2,3}) renvoie 6.\n
     =%NOM%({a,b}) renvoie a+b.

 {LIST_PRODUCT}
 DES=Calcule le somme des éléments de la liste définie.
 EXPL=%NOM%({}) renvoie 1\n
     =%NOM%({2,10,3}) renvoie 60.\n
     =%NOM%({a, b, c}) renvoie a*b*c.

 {LIST_MEAN}
 DES=Calcule la moyenne de la liste définie (qui doit contenir au moins un
    = élément)
 EXPL=%NOM%({a, b, c}) renvoie (a+b+c)/3.\n
     =%NOM%({10.5, 12, 8.5}) renvoie 10.333...

 {EXTRACT}
 DES=Extrait une partie de la chaîne de caractère %P1% depuis la position %P2%
    = d'une longueur de %P3% caractères.
 EXPL=%NOM%("Salut toi !",0,5) renvoie "Salut"\n
     =%NOM%("Salut toi !",6,3) renvoie "toi"\n
     =%NOM%({54,73,19},1,1) renvoie {73}\n
     =%NOM%({54,73,19},1,2) renvoie {73,19}

 {DELETE}
 DES=Efface %P3% éléments (caractères) à la position %P2% de la liste
    = (chaîne) %P1%.
 EXPL=%NOM%("Salut toi!",6,5) renvoie "Salut"\n
     =%NOM%("Fautes d'orthographe",6,1) renvoie "Faute d'orthographe"\n
     =%NOM%({1,2,3,4,5},1,3) renvoie {4,5}

 {COMPLETE_BEGIN}
 DES=Complète la liste/chaîne %P1% en rajoutant l'élément/caractère %P2%
    = au début de celui-ci pour qu'il atteigne la longueur '%P3%'.
 EXPL=%NOM%("123"," ",5) renvoie "  123"\n
     =%NOM%({a,b},0,4) renvoie {0,0,a,b}\n

 {COMPLETE_END}
 DES=Complète la liste/chaîne %P1% en rajoutant l'élément/caractère %P2%
    = à la fin de celui-ci pour qu'il atteigne %P3% éléments/caractères.
 EXPL=%NOM%("var="," ",6) renvoie "var=  "\n
     =%NOM%({1,2},0,4) renvoie {1,2,0,0}\n

 {SEQUENCE}
 DES=Génère une liste en évaluant l'expression %P1% pour %P2% variant
    = de %P3% à %P4% (inclus).
 EXPL=%NOM%(i^2,i,1,5) renvoie la liste des carrés de 1 à 5 : {1, 4, 9, 16, 25}

 {POS}
 DES=Recherche %P2% (élément/chaîne) dans la liste/chaîne %P1% en partant
    = de la position %P3%, renvoie FAUX si %P2% est introuvable.
 EXPL=%NOM%("aba",'a',0) renvoie 0\n
     =%NOM%("aba",'a',1) renvoie 2\n
     =%NOM%({10, 2, 7, 9},7,0) renvoie 2
     =%NOM%({10, 2, 7, 9},7,3) renvoie FAUX

 {IPOS}
 DES=Recherche %P2% (élément/chaîne) dans la liste/chaîne %P1% en partant
    = de la position %P3%, renvoie FAUX si %P2% est introuvable. La recherche
    = est insensible à la case (minuscule/majuscule) pour les recherches
    = avec %P2%=chaîne de caractère.
 EXPL=%NOM%("Salut toi !","SALUT",0) renvoie 0\n
     =%NOM%("Salut toi !","Salut",0) renvoie 0\n
     =%NOM%({'a', 'b', 'A'}, 'A') renvoie 0\n
     =%NOM%({'a', 'b', 'A'}, 'A', 1) renvoie 2

 {LIST_DIFF}
 DES=Différences de la liste %P1%.
 EXPL=%NOM%({a, b, c}) renvoie {b-a, c-b}

//--------------
// Programmation
//--------------
[Programmation]
 {IF}
 DES=Exécute '%P2%' si la condition '%P1%' est vérifiée, ou '%P3%' sinon.\n
    =Le paramètre '%P3%' est optionnel et 'sinon' sert
    = à séparer %P2% et %P3%.
 EXPL=%NOM% (x == 4) Affiche ("x égal 4") sinon Affiche("x = "&Str(x))

 {FOR}
 DES=Exécute %P1%, puis tant que la condition %P2% est
    = vérifiée, exécute l'instruction %P4% suivit de %P3%.
    = Renvoie le dernier résultat de %P4%.
 EXPL="Pour (i=1,i<=10,i++) Affiche (STR(i)&'\\n')"
     = affiche les nombres de 1 à 10

 {INPUT}
 DES=Affiche '%P1%' pour inviter l'utilisateur à saisir une valeur de type
    = '%P2%'. Renvoie la valeur saisie, ou NULL si la saisie est abandonnée.
 EXPL='%NOM%("Entrez un nombre : ","REAL")' vous invite à saisir un nombre,
     = puis le renvoie.

 {PRINT}
 DES=Affiche %P1% à l'écran.
 EXPL='%NOM%("Hello World!")' vous affichera "Hello World!".

 {PRINTN}
 DES=Affiche %P1% à l'écran, puis revient la ligne.\n
    =AfficheN(%P1%) est identique à Affiche(%P1%.'\\n')
 EXPL='%NOM%("Hello World!")' vous affichera "Hello World!",
     = puis revient à la ligne.

 {RETURN}
 DES=Stoppe l'exécution d'une fonction utilisateur et retourne la valeur %P1%.
 EXPL='F(x)=Si(x<0) Retourne(-1) sinon Racine(x)' : renvoie la racine de x,
     = ou -1 pour les valeurs négatives

 {WHILE}
 DES=Execute %P2% tant que la condition %P1% est vérifié,
    = renvoie le dernier résultat de %P2%.
 EXPL=n=40; TantQue(EstPremier(n)==FAUX) n++;

 {ERROR}
 DES=Affiche le message d'erreur '%P1%' et arrête le calcul en cours.

//----------------------------------
// Fonctions spécifiques à HaypoCALC
//----------------------------------

[HaypoCALC]
 {LOAD_FILE}
 DES=Charge le fichier nommé '%P1%'
    = comme s'il sagissait de commandes entrées au clavier. Très pratique
    = pour charger des fonctions utilisateur,
    = et utiliser un autre éditeur de texte que HaypoCALC.

 {HELP}
 DES=Aide de HaypoCALC : affiche des informations sur l'élément %P1%. On
    = peut utiliser plus simplement '? %P1%'.\n
    =Fonction : Affiche sa syntaxe, description, et exemple(s).\n
    =Constante
 EXPL="? Cos()" affiche l'aide sur la fonction cosinus.\n
     ="? F()" donne la définition de fonction utilisateur F.\n
     ="? $pi" donne la définition de la constante Pi.\n
     ="? x" dit si la variable x est définie ou non, et si c'est le cas
     = affiche sa valeur.

 {SET_CONFIG}
 DES=Change la valeur de l'option '%P1%'.\n
    =Utilisez la commande 'config' pour afficher les options à modifier.
 EXPL=%NOM%("exact",FAUX) -> Passe en mode de calcul approché.\n
     =-> 4/6 renvoie alors 0.6666... au lieu de 2/3

 {GET_CONFIG}
 DES=Lit le paramètre %P1% de configuration de la calculatrice.\n
    =Utilisez la commande 'config' pour afficher les options à modifier.

 {SET_DETAIL}
 DES=Active l'affichage du détail de calcul '%P1%' si %P2% vaut VRAI,
    = le désactive sinon.

 {GET_TYPE}
 DES=Renvoie le type de %P1%.
 EXPL=%NOM%(4) renvoie "ENTIER"\n
     =%NOM%(Cos) renvoie "FCT"

 {SET_TYPE}
 DES=Convertit l'élément %P1% dans le type %P2%.\n
    =Convertions possibles :\n
    =o NINT <- CHAR, STR, INT, REAL (arrondit à l'entier le plus proche)\n
    =o INT <- CHAR, STR, INT, REAL (arrondit à l'entier le plus proche)\n
    =o REAL <- INT, REAL, CHAR, STR\n
    =o CHAR <- CHAR, STR (si la chaîne ne contient qu'un caractère)\n
    =o STR <- Tous les types ;-)
 EXPL=%NOM%(67.3,"int") renvoie 67

 {IS_TYPE}
 DES=Est-ce que %P1% est compatible avec le type %P2% ?
 EXPL=%NOM%(4,"REAL") renvoie VRAI\n
     =%NOM%("abc","EXPR") renvoie VRAI.\n
     =%NOM%("abc","INT") renvoie FAUX.

 {UNSET_VAR}
 DES=Efface la variable nommée '%P1%'.

 {UNSET_UFCT}
 DES=Efface la fonction utilisateur nommée '%P1%'.

 {HISTORIC}
 DES=Renvoie le résultat numéro %P1%.
    = Le résultat précédent est donné par @(1).
 EXPL=@(1)^2 renvoie le résultat précédent élevé au carré.

 {APPROX}
 DES=Calcule l'expression %P1% en mode 'calcul approché'.\n
    =Remarque: Utilisez 'config("approx",vrai)' pour passer en mode
    = 'calcul approché'.
 EXPL=%NOM%($pi/2) renvoie 1.570796...

 {EXACT}
 DES=Calcule l'expression %P1% en mode 'calcul exact'.\n
    =Remarque: Utilisez 'config("approx",vrai)' pour passer en mode
    = 'calcul exact'.
 EXPL=%NOM%(21/35) renvoie 3/5.

 {RENAME}
 DES=Renomme une variable ou une constante, on peut renommer des fonctions en
    = ajoutant à '%P1%' le suffixe '()'.
 EXPL=%NOM%("x","y") : renomme la variable 'x' en 'y'.\n
     =%NOM%("Cos()","cs") : renomme la fonction 'Cos' en 'cs'.\n
     =%NOM%("$e","$exp1") : renomme la constante '$e' en '$exp1'.

 {BENCHMARK}
 DES=Chronomètre la durée du calcule de %P1%,
    = puis renvoie la durée en milli-secondes (nombre entier).

 {DONT_EVAL}
 DES=Renvoie l'expression %P1% sans l'évaluer.
 EXPL=%NOM%(1+2) renvoie 1+2.

 {RESET}
 DES=Réinitialise la calculatrice : efface les variables, les fonctions
    = utilisateurs, remet la configuration par défaut et vide l'historique.\n
    =Remarque: Une confirmation est demandée pour chaque opération.

 {GET_FUNC_NAME}
 DES=Lit le nom internationnal de la fonction %P1% (qui doit être exprimé
    = sous forme d'une chaîne de caractère).
 EXPL=%NOM%("Pgcd") renvoie "GCD"

 {ELEMENT_NB}
 DES=Compte le nombre d'éléments qui composent l'expression %P1%.
 EXPL=%NOM%(1) renvoie 1\n
     =%NOM%(cos(x+1)*2) renvoie 6