Notice d'utilisation de la CALCULEXT

version 1.30    [Tyrtamos - Déc 2007]

La calculext est une calculatrice scientifique, présentée dans une fenêtre graphique, qui permet de calculer des expressions (algériques et autres) très diverses et si nécessaire très complexes.

Elle a en plus l'avantage d'être facilement extensible par ajout de nouvelles fonctions (mathématiques et autres) par l'utilisateur.

Elle fonctionne de la même façon sur Windows et sur Linux, et c'est le même programme pour les 2 OS.

Elle est programmée dans le langage Python, et vous avez droit à toutes les possibilités de calcul d'expressions en python (=tout ce que la fonction "eval()" peut supporter). Reportez-vous au manuel python pour plus d'info.

Cette notice traite aussi des fonctions additionnelles (et optionnelles) que je vous propose et que vous ne trouverez pas dans les manuels python.

A noter qu'à partir de la version 1.30, on peut aussi utiliser la calculext sans l'installer, parce que je vous propose une version web "en ligne". Il vous suffira d'un simple navigateur web et, bien sûr, d'une connexion Internet. Elle se trouve ici: http://calculext.jpvweb.com/ . Elle a quelques limitations qui se trouvent au début de sa propre notice. Les modules additionnels utilisés sont les mêmes que pour la présente calculatrice. Bien entendu, si vous avez besoin d'ajouter de nouvelles fonctions, vous préférerez la calculext installable qui met son code à votre disposition.

Amusez-vous bien!

Sommaire de l'aide

• Sites web de reference

• Fonctionnement de la calculette

• Types de données et conversions entre les données

• Fonctions de base de la calculette

• Fonctions intégrées de calcul d'expression

• Fonctions des modules additionnels

Sites web de référence

Pour la calculette CALCULEXT: http://linux.jpvweb.com/mesrecetteslinux/calculatrice

Pour les fonctions courantes du langage python, vous pouvez avoir des infos complémentaies ici:

• http://python.developpez.com/cours/PythonDocs/  (documentation générale sur python en français)

Pour le developpement de fonctions supplémentaires:

• ftp://ftp-developpez.com/python/cours/TutoSwinnen/fichiers/python_notes.pdf (tutoriel général en français)

• ftp://ftp-developpez.com/python/cours/TutoVanRossum/fichiers/TutorielPython.pdf (tutoriel en français)

• http://www.python.org/doc/ (doc générale sur python en anglais)

• http://www.pythonware.com/library/ (doc générale sur python en anglais)

• etc...

Et pour utiliser la calculext en ligne (donc sans l'installer): http://calculext.jpvweb.com/

Fonctionnement de la calculext

La calculext dans sa version installable sur PC s'exécute dans une fenêtre graphique:

Une fois la calculatrice lancée, on peut taper une formule (algébrique ou non) quelconque dans la zone de saisie blanche.

L'édition dans la zone de saisie se fait avec toutes les facilités habituelles d'édition, y compris le copier-coller.

Attention: pour l'introduction et l'affichage des nombres décimaux, la virgule est toujours remplacée par un point décimal: c'est 3.14 et pas 3,14!

Un clic droit de souris sur la zone de saisie fait apparaitre un menu flottant à 2 niveaux. Si vous sélectionnez une fonction dans le menu 2ème niveau, celle-ci s'insère à l'endroit du curseur de la zone de saisie. Si la fonction a des parenthèses, le curseur se positionne entre elles.

L'exécution est lancée par le bouton "Calculer" ou par la touche de clavier "retour". (clavier normal et clavier numérique).

Quelque soit le résultat:

• il est affiché dans la zone de résultat jaune: nombre, booléen, chaîne de caractère, liste, message d'erreur ou message indiquant un arrêt demandé par l'utilisateur,

• le temps de calcul est affiché en millisecondes(en dessous du mot "Résultat=").

• Lorsque le résultat à afficher dépasse la zone résultat, on peut naviguer dedans grâce à l'ascenseur horizontal.

L'effacement des 3 zones (saisie, résultat et durée du calcul) peut être obtenu par le bouton "Effacer" ou par la touche de clavier "échappement".

La touche de clavier "flèche en bas" fait venir le dernier résultat calculé dans la zone de saisie, ce qui permet d'enchaîner les calculs avec le dernier résultat obtenu sans le retaper au clavier.

Au delà du 2ème calcul fait, la touche de clavier "flèche en haut" fait venir les formules précédentes dans la zone de saisie.

Le bouton "Aide" ou la touche de clavier [F1] fait venir la présente page d'aide dans le navigateur web par defaut.

Une fois lancé, le calcul s'exécute en tâche de fond, et peut être interrompu s'il dure trop longtemps (bouton “stopper” ou touche [F2]).

La séquence de touches Ctle-R ("R" pour Résultat) sauvegarde le dernier résultat calculé sur disque, à la fin du fichier resultat.txt. Pour que l'action soit exécutée, il faut que le focus (=le curseur) soit sur l'une des 2 lignes (saisie ou résultat).

La séquence de touches Ctle-E ("E" pour Expressions) sauvegarde la liste de toutes les expressions calculées depuis le lancement de l'exécution de la calculatrice, complétée par le dernier résultat calculé. Cette liste est ajoutée au fichier resultat.txt. Pour que l'action soit exécutée, il faut que le focus (=le curseur) soit sur l'une des 2 lignes (saisie ou résultat).

Arrêt normal de la calculette par la croix dans la case rouge en haut à droite de la fenêtre.

Pour les nombres réels (à virgule flottante), les calculs sont toujours faits en double précision, c'est à dire avec 16 ou 17 chiffres significatifs, mais l'affichage se limite à 15 chiffres significatifs pour éviter les résultats irritants comme 0.1 => 0.10000000000000001. Ce n'est pas un problème spécifique python qui utilise la bibliothèque C, mais cela correspond à la façon dont les nombres à virgule flottante sont stockés en mémoire dans l'ordinateur. Il est possible de changer ce mode d'affichage des nombres réels, ponctuellement ou en permanence: voir ci-dessous le chapitre qui traite des nombres réels.

Types de données et conversions entre les données

Booléen (type bool)

Un booléen est une donnée qui ne peut prendre que 2 valeurs: True (=vrai) et False (=faux).

NB: ne pas oublier que la 1ère lettre est en majuscule

Dans la calculette, si vous calculez "1==2", le résultat est "False". Si vous calculez "2<3", le résultat est "True"

Certaines fonctions additionnelles renvoient un résultat booléen comme bissextile(2008) => True qui dit que l'année 2008 est bissextile.

Cela permet de faire des calculs logiques aussi complexe que vous voulez avec des opérateurs comme "and" (=et), "or" (=ou) et "not" (=non).

Nombre entier (type int)

Un entier est un nombre sans virgule ni exposant. Exemples: 12   785   5   99

Un entier est en général compris entre -2^{31 et} 2³¹-1 (cela dépend de la machine dont vous disposez)

Vous pouvez calculer cela avec la calculette: cela donne de (-2**31)=-2147483648 à (2**31-1)=2147483647

La valeur correcte pour votre machine se trouve dans la variable "sys.maxint" . Vous pouvez en afficher la valeur avec la calculette:

Heureusement, si un calcul devait dépasser cette valeur maxi, python la convertirait automatiquement en entier long!

Nombre entier long (type long)

Pour python, un entier long est un entier dont le nombre de chiffres n'est limité que par la mémoire...

Pour entrer un nombre entier long dans une expression: il suffit d'ajouter un "L":

C'est en général inutile, car Python convertit automatiquement un entier en entier long si c'est nécessaire.

Cela permet de faire des calculs assez rares avec votre calculette, comme, par exemple 2 à la puissance 1000 :

qui renvoie (sur une seule ligne!):

Vous récupérez le résultat par copier-coller ou avec la  séquence de touche Ctle-R.

Vous noterez que le résultat est affiché avec le "L" à la fin, ce qui permet à ce nombre d'être réutilisé dans d'autres calculs sans perdre sa définition.

Conversion d'un entier sur plusieurs bases: 2, 8, 10, 16 et ascii

Un même nombre peut être exprimé selon plusieurs bases de numération. Par exemple le nombre 123:

• en base 10 (=décimal): 123,
• en base 8 (=octal): 0173
• en base 16 (=hexadécimal): 0x7b
• et en base 2 (=binaire): 1111011

La calculette donne toutes les possibilités de conversion dans les 2 sens:

Pour les conversions en binaire (module additionnel "bibgene"):

Pour saisir un nombre binaire, n'oubliez pas les guillemets ou les apostrophes: c'est une chaîne de caractère.

Et, bien sûr, il n'y a pas de réelle limite de précision, tant qu'on reste avec les nombres entiers:

Conversion avec les caractères (très pratique pour les informaticiens!)

Nombre réel ou à virgule flottante (type float)

Un nombre réel (ou à virgule flottante), est un nombre qui a une virgule et/ou un exposant. Ex: 1.2  0.365   1.87e15   8.9E-5

Attention: dans la calculette, la virgule sera toujours introduite et affichée par un "point décimal" (comme les anglo-saxons)

Le réel de python correspond au "double précision" du langage C, avec environ 17 chiffres significatifs et une étendue de 10^-308 à 10⁺³⁰⁸

L'utilisateur peut changer le mode d'affichage des nombres réels, grâce à la fonction "precision(n)", selon la valeur de n entre -15 et +15:

• avec n<0, on obtient un affichage "intelligent" avec abs(n) chiffres significatifs. C'est le mode d'affichage courant, et il convient bien aussi aux applications scientifiques.

• avec n>=0, on obtient un affichage avec n chiffres après la virgule. Par exemple avec "precision(2)", on aura des résultats financiers plus satisfaisants. Par contre, ce n'est pas un bon affichage pour les nombres avec exposants.

• avec "precision()" sans paramètre, on revient à l'affichage par défaut avec n=-15.

• le dernier chiffre à l'affichage est arrondi à la valeur la plus proche. Ex avec le mode par défaut: 1.111111111111114 s'affiche 1.11111111111111 et 1.111111111111116 s'affiche 1.11111111111112.

Cet affichage fonctionne aussi:

• si ces nombres réels se trouvent à l'intérieur d'une liste ou d'un tuple, et ce, quelque soit sa profondeur (liste de liste de liste...).

• dans les nombres complexes. Par exemple: complex(0.1,2) s'affiche (0.1+2j) et non (0.10000000000000001+2j)

On peut obtenir le même effet ponctuellement, c'est à dire sans changer le mode courant d'affichage, avec la fonction arrond(x,n). Par exemple, arrond(0.1,4) => "0.1000" ne change pas "nbchiffres" qui peut rester à -15.

Nombre complexe (type complex)

Un nombre complexe est un nombre composé d'une partie réelle et d'une partie imaginaire. Ex: (2, 9j) => partie réelle=2, partie imaginaire=9. Le "j"  est un symbole qui représente racine de -1. Ici, comme souvent en informatique, c'est "j" qui est utilisé (pratique anglo-saxonne), et non "i".

Les 2 parties numériques sont des nombres à virgules flottantes: (2,9j) est codé et utilisé comme  (2.0,9.0j).

Exemple de calcul sur les nombres complexes:

Une expression saisie comme (1,2j) n'est pas tout de suite considérée comme un nombre complexe, mais comme une sorte de liste (appelée "tuple" en Pyhon). Pour que ce soit un nombre complexe, il faut le dire à la calculette par complex(1,2). Mais si on affecte le résultat à une variable, celle-ci est utilisée après comme un nombre complexe sans qu'on ait à le rappeler::

Le calcul sur les nombres complexes avec les fonctions trigonométriques (et autres) nécessite l'importation du module "cmath". Il est ici importé avec "import cmath", ce qui oblige les fonctions à être préfixées avec "cmath.". C'est pour ne pas confondre avec les fonctions du module "math" qui portent le même nom. Exemple:

Liste non commentée des fonctions du module "cmath" dédiées aux nombres complexes:

• acos(), acosh(), asin(), asinh(), atan(), atanh(), cos(), cosh(), exp(), log(), log10(), sin(), sinh(), sqrt(), tan(), tanh()
• ainsi que les mêmes constantes "pi" et "e" que pour les réels.

A noter que toutes les fonctions dédiées aux complexes ne renvoient que des complexes. Dans ce cas, un nombre réel est simplement un nombre complexe dont la parte imaginaire est nulle (ex: "(2,0j)").

Conversion entre les principaux types de données numériques

Conversion automatique:

Lorsque l'interpréteur python doit appliquer un opérateur de calcul entre deux nombres et que ces 2 nombres n'ont pas le même type, il convertit automatiquement l'un des types dans l'autre.

Les choix automatiques sont les suivants int -> long -> float -> complex et vont toujours dans ce sens.

Conversion à la demande:

On peut appliquer une conversion de type (= transtypage) de la façon suivante:

Nombre décimal (type Decimal)

Le type Decimal est un type particulier qui emprunte certaines caractéristiques aux entiers long et aux réels: il a une virgule et peut comporter un nombre quelqconque de chiffres significatifs définis à l'avance..

Il est apporté par le module "decimal"

Il permet des calculs décimaux (avec une virgule comme un réel) mais avec une précision supérieure aux réels en nombre de chiffre, et sans avoir les effets bizarres sur les derniers chiffres comme avec lesnombres à virgule flottante.

Ce type est à utiliser pour des applications comme la comptabilité.

Exemple extrème d'utilisation pour laquelle les nombres type float ne pourrait convenir:

Actuellement, les changements de precision ne peuvent se faire que dans une liste de calculs enchaînés comme:

chaîne de caractères (type str)

Les chaînes de caractères sont des morceaux de texte comme par exemple: "n'importe quoi pourvu que ça mousse".

Les chaînes sont entourées par des guillemets (comme dans "toto") ou des apostrophes (comme dans 'toto'). L'intérêt d'avoir 2 signes possibles est qu'on peut utiliser l'un, pour des textes qui contiennent l'autre.

Bien entendu, les chaînes ne peuvent pas être utilisées directement dans les calculs numériques, mais certaines fonctions les utiliseront en entrée ou en sortie: Par exemple:

Listes (type list)

Une liste est un assemblage de plusieurs valeurs, séparées pardes virgules et entourés par des crochets. Par exemple, [2, 3.7, 0.7, 99].

Python est très doué pour manipuler les listes.

Qu'est-ce que ça vient faire dans une calculatrice? La liste est utilisée quand une fonction doit renvoyer plusieurs valeurs. Par exemple, "facteurs(n)" du module additionnel "arithmétique" renvoie la décomposition de n en facteurs premiers sous forme d'une liste de nombres:

Et pour permettre l'enchaînement des calculs (utilisation directe du résultat précédent comme donnée pour le calcul suivant), certaines fonctions acceptent une liste comme paramètre (ne pas oublier les crochets):

Vous pouvez manipuler les listes:

• affecter la liste à une variable:

• extraire  une ou plusieurs valeurs que vous pouvez utiliser directement dans une expression (les indices commencent par zéro):

On peut avoir des listes de n'importe quoi, y compris des listes de chaînes ou même des listes de listes.

Fonctions de base de la calculette

Fonctions pour avoir de l'aide

Pour avoir l'aide générale (la présente page):

• touche F1 ou bouton "aide"

Pour avoir l'aide sur une fonction en particulier, calculez "aide(nomdelafonction)".

Par exemple:

NB: l'aide pour les fonctions intégrées "python" est en anglais

NB: c'est une fonction du module additionnel "temps" et l'aide est en français

Et, bien sûr (je ne pouvais pas rater ça  ;-) ):

Création dynamique de variables et affectation de valeurs

Une formule comme x=2*sin(0.5)/pi ne marchera pas avec votre calculette, parce que l'affectation du résultat d'une expression à une variable n'est pas elle-même une expression valide pour python. Seule la partie droite après le signe "="  est une expression valide.

Alors, j'ai fabriqué une fonction qui fait la même chose: sto("x",2*sin(0.5)/pi).  

sto("x", E) affecte la valeur de l'expression E à la variable x. Si x n'existe pas, une nouvelle variable portant ce nom est créée. Si x existe, elle porte désormais la nouvelle valeur de E et la précédente est perdue.

Dans cette formule, E peut être une expression quelconque donnant un résultat d'un type quelconque.

Exemple:

Comme la fonction "sto" renvoie la valeur de l'expression, vous pouvez l'utiliser à l'intérieur d'une autre expression:

Après cette expression, vous pouvez utiliser directement la variable toto dans un autre calcul. Sa valeur 2**3 => 8 sera utilisée:

Contrairement à d'autres langages plus "typés", la même variable peut porter des valeurs de différents types au gré de ses affectations successives:

Si par prudence vous voulez vérifier que la variable "toto" n'est pas déjà utilisée par le système, vous demandez son exécution dans la calculatrice. si elle n'existait pas, son résultat est "error". Sinon, c'est sa valeur qui est affichée.

Fonctions intégrées de calcul d'expression

Constantes mathématiques prédéfinies

pi = 3.14159265359

e = 2.71828182846

Opérateurs et fonctions mathématiques de base

Il y a les priorités habituelles entre tous ces opérateurs. En cas de doute, utilisez les parenthèses.

+ => addition

- => soustraction

* => multiplication

/ = division. Attention: contrairement aux habitudes python, les divisions entre 2 entiers sont décimales et non entières! Par exemple: 10/3 donnera "3.3333333333333333" .

// = division avec troncature (ex: 10.0//3 => 3.0 au lieu de 3.33333333333)

** = élévation à un puissance (ex: 2**3 => 8)

pow(x,y) => idem à x**y

% = reste de la division entière (ex: 11%2 => 1) = fonction "modulo"

( et ) = parenthèses

sqrt(x) => racine carrée de x (ex: sqrt(2) => 1.41421356237)

exp(x) => e élevé à la puissance x (ex: exp(2) => 7.38905609893)

floor(x) => arrondi à l'entier inférieur: floor(3.9) donne 3.0, et floor(-3.9) donne -4.0.

log(x) => logarithme népérien de x (ex: log(e) => 1.0)

log10(x) => logarithme base 10 de x (ex: log10(10) => 1.0)

abs() => donne la valeur absolue (ex: abs(-5) => 5 et abs(-5.1) => 5.1

fabs() => idem, mais renvoie toujours un nombre réel (ex: fabs(-5) => 5.0)

Opérateurs logiques

>, >=, <, <=,  ==, != comparent 2 nombres et renvoient True (=vrai) ou False (=faux)selon le résultat

and fait un "et" booléen entre 2 états True et False (ex: True and True => True)

or fait un "ou" booléen entre 2 états True et False (ex: True or False => True)

not fait un "non" booléen (ex: not True => False)

Opérateurs binaires

& permet un "et" bit à bit (ex: 2&6 => 2)

| pemet un "ou" bit à bit (ex: 2|6 => 6)

^ permet un "ou" exclusif (ex: 2^6 => 4)

~ fait un "non" bit à bit

<< et >> = décalage de bits à gauche et à droite (ex: 2<<1 => 4)

Priorité décroissante des opérateurs

(la même liste se trouve dans le menu flottant)

Fonctions trigonométriques

Toutes les fonctions trigonomériques utilisent les angles en radians

degrees(x) transforme des radians en degrés décimaux. Par exemple: degrees(pi/2) => 90.0

radians(x) transforme des degrés décimaux en radians. Par exemple radians(90.0) => 1.5707963267948966 soit pi/2. Si vous avez un angle en "20°, 35mn 12sec", vous faites la conversion dans la fonction: radians(20+35/60+12/3600)

sin(x) => sinus de x

cos(x) => cosinus de x

tan(x) => tangente de x

acos(x) => arc cos x

asin(x) => arc sin x

atan(x) => arc tangente de x

sinh(x) => sinus hyperbolique de x

cosh(x) => cosinus hyperbolique de x

tanh(x) => tangente hyperbolique de x.

hypot( x, y) => valeur de l'hypothénuse d'un triangle rectangle de côté x et y (=sqrt(x*x + y*y))

Fonctions diverses

lambda  si vous avez une expression complexe à calculer plusieurs fois avec des valeurs différentes, ça peut être assez pénible de changer les valeurs directement dans le texte de l'expression. Par exemple, la fonction:

Vous voulez calculer cette fonction avec d'autres valeurs que 0.25698 (qui intervient à 2 endroits) et 1.6987. Vous faites:

Désormais, vous pouvez calculer:

Dans le contexte de la calculette, vous pouvez utiliser un ou plusieurs paramètres avec “lambda”, voire même une liste de paramètres. Mais vous n'avez droit qu'à une seule expression après le ”:” (et pas d'instruction python comme print, x=, for, while etc...).

map(f,L): permet de calculer une fonction f avec chaque valeur d'une liste L de paramètres, et de restituer la liste des résultats

Exemple avec la fonction sinus, qui va donc calculer sin(0.1), puis sin(0.2), etc…:

On peut faire des choses étonnantes avec map(). Exemple , vous obtenez ici les dates de Pâques des 5 prochaînes années (fonction jeuxdessais: module bibgene et fonction paques: module temps):

filter(f,L): permet de ne retenir d'une liste L que les valeurs qui rendent la fonction f vraie.

Par exemple, on fabrique la fonction lambda qui donne vrai quand son paramètre y est >=100:

Et on cherche la liste des nombres premiers compris entre 100 et 200:

On peut aussi chercher, par exemple, des variables aléatoires distribuées au hasard selon la loi normale réduite (module probabilite), mais en ne retenant que les valeurs positives. Dans cet exemple, nous avons enchaîné les expressions dans une liste:

Compréhension de liste

C'est une appellation étrange, parce que ce n'est pas forcément facile à "comprendre". Il s'agit d'une boucle conditionnelle dans une liste qui est considéré par Python comme une expression, et donc qui est calculable par la calculext. Par exemple:

Dans cette expression:

• "3*x" est l'expression à calculer.

• "for x in range(0,10)" est la boucle qui permettra de calculer la fonction précédente avec x=0 jusqu'à x=9 (10 est exclu).

• "if x%2==0" est la condition qui fera que de toutes les valeurs calculées par la boucle, seules les valeurs paires seront retenues (% est la fonction modulo).

• le résultat est renvoyé sous forme d'une liste.

La condition avec "if" est optionnelle. Par exemple: les 5 prochaines dates de Pâques:

On peut, bien sûr, combiner toutes ces fonctions: sto, lambda, map, filter, compréhension de liste, etc... pour obtenir ce qu'on veut.

Fonctions des modules additionnels

Cette partie de l'aide est destinée à être mise à jour au fur et à mesure de l'évolution des modules utilisateurs

Module "bibgene"

Bibliothèque générale / fonctions diverses

dec2bin(x) convertit un entier en nombre binaire (=chaîne de caractère).

dec2bin(x, L)convertit un entier en nombre binaire (=chaîne de caractère) en ajoutant des zéros à gauche pour atteindre la longueur L.

• NB: dans les 2 cas, le résultat est une chaîne inutilisable pour intégration directe dans les calculs suivants (utilisez bin2dec() pour cela)

dec2bins(x, L=8) convertit un nombre entier signé en nombre binaire signé par la méthode du complément à 2.

• la conversion pour un nombre négatif n'a de sens que si on précise la taille du mot (=nb de bits). Ici, le mot par défaut est "8 bits", mais on peut donner autre chose (16 bits dans cet exemple).

bin2dec(x) convertit un nombre binaire en entier décimal (ne pas oublier les guillemets autour du nombre binaire: c'est une chaîne!)

bin2decs(x,L=8) convertit un nombre binaire signé en entier décimal signé (ne pas oublier les guillemets!) par la méthode du complément à 2.

• la conversion pour un nombre négatif n'a de sens que si on précise la taille du mot (=nb de bits). Ici, le mot par défaut est "8 bits", mais on peut donner autre chose (16 bits dans cet exemple).

deg2dms(DD) convertit des degrés décimaux en une liste [degrés, minutes, secondes].

dms2deg(L) convertit une liste [degrés, minutes, secondes] en degrés décimaux.

jeuxdessais(n,L1,L2): construit une liste de n jeux de paramètres commençant à L1 et se terminant à L2.

• Si L1 et L2 sont des valeurs numériques, la fonction renvoie une liste de n valeurs numériques dont la 1ère est L1 et la dernière L2, les valeurs intermédiaires étant calculées (nombres réels):

• Si L1 et L2 sont des listes de paramètres, la fonction renvoie une liste de n listes de paramètres, le 1er jeu de paramètres étant L1 et le dernier L2, les jeux intermédiaires étant calculés (nombres réels):

Avec lambda et map(), on peut obtenir une liste de valeurs d'une fonction testée avec n valeurs de plusieurs paramètres passés à la fonction.

Créer une fonction avec lambda. On prend l'exemple ici d'une fonction simple avec 3 paramètres passés dans une liste L. Cette fonction se contente de renvoyer la somme des 3 paramètres:

Et on va utiliser la fonction python “map()” pour appliquer ces jeux de paramètres à la fonction X:

volcuve(h,d,vt): calcule le volume de liquide restant dans une cuve cylindrique horizontale de diamètre d et de volume total vt, à partir de la hauteur h du liquide.

Par exemple, j'ai une cuve de diamètre 1.20 m qui contient 3500 litres de mazout, et il m'en reste une hauteur de 40cm: combien j'en ai en litres?

Remarques:

• cette formule suppose que le volume total indiqué est le volume qui remplit complètement la cuve cylindrique, c'est à dire que: volcuve(120,120,3500) => 3500.
• pour la hauteur et le diamètre, vous pouvez utiliser l'unité que vous voulez (m, cm, mm), à condition d'utiliser la même pour les 2.
• le résultat est exprimé dans la même unité que le volume total (des litres par exemple)

mdp2hex(ch): Convertit en séquence hexadécimale les mots de passe donnés en texte clair. Utilisation: les mots de passe utilisés en wifi. Exemple:

hex2mdp(ch): Convertit en texte clair les mots de passe donnés en séquence hexadécimale. Exemple:

Module "arithmetique"

fact(n) = factorielle n = 2*3*4*5*...*n  (n doit être une entier >=0). Permet le calcul avec des valeurs très grandes. Exemple:

En quelques secondes, on peut aussi calculer fact(5000) qui comporte tout de même 16325 chiffres!

pgcd(a,b) = PGCD de a et b => Plus Grand Commun Diviseur des 2 nombres entiers (>0) a et b.

• plus d'infos ici: http://fr.wikipedia.org/wiki/Plus_grand_commun_diviseur

ppcm(a,b) = PPCM de a et b => Plus Petit Commun Multiple des 2 nombres entiers (>0) a et b.

• plus d'infos ici: http://fr.wikipedia.org/wiki/Plus_petit_commun_multiple

facteurs(n) = décomposition en facteurs premiers => renvoie la liste des facteurs premiers trouvés.

estpremier(n) = teste si le nombre entier "n" est premier ou non => renvoie True s'il l'est et False sinon.

premiers(n) = calcule tous les nombres premiers inférieurs ou égaux à n => renvoie la liste.

• Attention, pour n>10000, on atteint vite les capacités d'affichage! Par exemple, "premiers(1000000)" trouve bien les 78.498 nombres premiers, mais ne peut pas les afficher. Vous pouvez le vérifier avec "len(premiers(1000000))" qui renverra le nombre de valeurs trouvées sans les afficher. Vous pouvez sauvegarder le résultat avec Ctle-R, même s'il n'est pas affiché. Il est alors ajouté au fichier résultat.txt.
• Soyez raisonnable: avec n à 20 chiffres, vous risquez fort d'attendre le résultat plusieurs mois...
• Tous les nombres premiers jusqu'à 1 000 000 000 sont ici http://nombrespremiersliste.free.fr/.

Module "combinatoire"

permut(n) = nombre de permutations possibles de n objets. Le calcul est le même que factorielle de n: Ainsi, il y a 6 possibilités de ranger les 3 objets A, B et C: ABC, BCA, CAB, ACB, CBA, BAC.

arrang(n,p) = arrangement de n objets pris p à p, en tenant compte de l'ordre, c'est à dire que "AB" et "BA "sont deux cas différents .

combin(n,p) = combinaison de n objets pris p à p sans tenir compte de l'ordre, c'est à dire que "AB" est le même cas que "BA"

A noter que nous avons, bien entendu:

Module "probabilite"

binom(k,n,p) = loi binomiale => probabilité d'avoir k réussite(s) dans n évènements indépendants, chaque évènement ayant une probabilité p de réussite..

binomcum(k,n,p) = loi binomiale cumulée =>  probabilité d'avoir 0, 1, ..k  réussite(s) dans n évènements indépendants, chaque évènement ayant une probabilité p de réussite.

Ce qui correspond à: binom(0,10,0.2)+binom(1,10,0.2)+binom(2,10,0.2)

hypgeo(k,n,g,t) = loi hypergéométrique => probabilité d'avoir k réussite(s) dans n évènements indépendants, sachant qu'il y a g réussites dans la population de taille t.

Par exemple, nous avons 30 billes rouges dans un lot de 100 billes, et nous en prélevons 10 au hasard, (c'est à dire que chaque bille a une chance égale d'être prélevée). La probabilité qu'il y ait 2 boules rouges dans cet échantillon de 10 billes est:

Remarque: quand la taille de l'échantillon (n) est <10% de la taille de la population (t), on commet peu d'erreur en utilisant la loi binomiale.

hypgeocum(k,n,g,t) = loi hypergéométrique cumulée => probabilité d'avoir 0,1,..,k  réussite(s) dans n évènements indépendants, sachant qu'il y a g réussites dans la population de taille t.

Même exemple que précédemment, à part que nous voulons connaître la probabilité d'obtenir 0 ou 1 ou 2 billes rouges dans l'échantillon de 10 billes:

Cela correspond, bien entendu, à: hypgeocum(0,10,30,100)+hypgeocum(1,10,30,100)+hypgeocum(2,10,30,100)

Remarque: quand la taille de l'échantillon (n) est <10% de la taille de la population (t), on commet peu d'erreur en utilisant la loi binomiale.

pgaussred(x) = probabilité qu'une variable aléatoire distribuée selon une loi normale réduite soit inférieure à x

Remarque: le calcul est obtenu par "intégration numérique", en calculant l'intégrale par ajout de nombreux petits rectangles (2000 par écart type). Le calcul reste très rapide puisque pgaussred(3) qui demande le calcul de 6000 rectangles (avec une exponentielle à chaque rectangle) ne demande que 1/100 seconde. Vous pouvez compter sur une précision d'au moins 5 ou 6 chiffres après la virgule. A partir de 8 écarts types, la fonction renvoie "1", ce qui est normal parce que la différence par rapport à 1 devient inférieure au 16ème chiffre après la virgule et dépasse donc les capacités de calcul de la bibliothèque du C en double précision.

pgauss(x,m,s) = probabilité qu'une variable aléatoire distribuée selon une loi normale (m=moyenne, s=écart-type) soit inférieure à x.

On trouve bien entendu la même valeur que précédemment, puisque x=8 correspond ici à la moyenne (m=2) plus 2 écarts types (2*s = 6)

xgaussred(p) = renvoie la variable x distribuée selon la loi normale réduite, et correspondant à la probabilité p  que la variable soit <= x (ce sont les "fractiles" des tables papier)

xgauss(p,m,s) = renvoie la variable x distribuée selon une loi normale (m=moyenne, s=écart-type), et correspondant à la probabilité p que la variable soit <=x

hgaussred(n=1) = renvoie une valeur au hasard de la variable x distribuée selon la loi normale réduite. Si n (optionnel) est >1, renvoie une liste de n valeurs.

Le principe de ce calcul est très simple. On tire au hasard une probabilité p avec random(), et on cherche le x correspondant avec la fonction xgaussred(p).

hgauss(m,s,n=1) = renvoie une valeur au hasard de la variable x distribuée selon une loi normale (m=moyenne, s=écart-type). Si n (optionnel) est >1, renvoie une liste de n valeurs.

Module "credit"

menscredit(C, IA, N): => calcul de la mensualité de remboursement d'un crédit, correspondant à un capital emprunté de C avec un intérêt de IA en % (ex: "10" pour 10%) par an à rembourser en N mois.

Par exemple, on emprunte 1000 Euros à 10% par an, à rembourser en 12 mois:

Remarques:

• pour éviter d'avoir des résultats à 15 chiffres après la virgule, utilisez la fonction arrond(). Par exemple, ici: arrond(menscredit(1000,10,12),2) donne bien "87.92".
• le résultat est donné dans la même unité que le capital emprunté: euros, dollars, francs, yen, etc...

moiscredit(C,IA,M) => trouve le nombre de mois de remboursement d'un prêt, connaissant le capital emprunté C, l'interet annuel IA% et la mensualite M

Par exemple, on emprunte 1000 euros à 10% par an, et on rembourse 87.92 euros par mois: pendant combien de mois?

Remarque: si le nombre de mois trouvé est décimal (ex: 20.5), le crédit devrait comporter un dernier mois avec une mensualité inférieure aux autres

capcredit(IA,M,N) => trouve le capital emprunté à IA%/an d'intérêt, remboursé en N mois avec une mensualité de M

Par exemple, on se sent capable de rembourser 87.92 euros pendant 12 mois avec un crédit à 10% par an. Quel capital peut-on emprunter avec ça?

Remarque: fonction à utiliser lors d'un achat important pour estimer ses propres capacités maxi d'emprunt. Par exemple, pour une maison, un remboursement maxi de 1500 Euros par mois sur 25 ans à 4% par an donne un emprunt  de 284178. euros (calculé par capcredit(4,1500,300)). A noter qu'en France, les banques limitent les remboursements de l'ensemble des crédits à 30% des revenus. Les américains devraient faire ça pour éviter les crises bancaires... (crises qu'ils exportent ensuite généreusement partout dans le monde).

intcredit(C,M,N) => calcule l'intérêt annuel IA% correspondant à un capital emprunté C, une mensualité M et un nombre de mois N de remboursement.

Par exemple, un organisme de crédit à la consommation vous propose de vous prêter 1000 euros à 14% par an, à rembourser par 50 euros par mois pendant 24 mois: Sa proposition est-elle correcte?

Non, ce n'est pas correct: C'est du 18% et pas 14%. Soit il ne sait pas compter, soit il vous ment. Dans les 2 cas, cherchez ailleurs!

coutcredit(C,M,N,sup=0) => calcule le coût d'un crédit connaissant le capital emprunté C, la mensualité M et le nb de mois de remboursement N

Ce n'est qu'une récapitulation facile à calculer (50*24-1000). On peut ajouter comme 4ème paramètre des frais supplémentaires, s'ils n'ont pas déjà été intégrés dans la mensualité (exemple: 20 euros=frais de dossier):

Vous pouvez obtenir directement le pourcentage que cela représente par rapport au capital emprunté, en divisant par le capital emprunté (=1000 ici) et en multipliant par 100 pour avoir les pourcentages:

Module "temps"

tempsordi() => donne la date et l'heure de l'ordinateur avec le jour de la semaine (en français) sous le format.

tempsntp(sntp='ntp.univ-lyon1.fr') => donne la date et l'heure exacte (à la seconde) par consultation d'un serveur de temps "ntp" (nécessite un accès internet). Le serveur ntp par defaut: est: "ntp.univ-lyon1.fr" mais on peut en donner d'autres (voir http://www.cru.fr/services/ntp/serveurs_francais). J'ai vérifié que l'heure était la même à la seconde près qu'une horloge dont la mise à jour est faite par radio.

cetteheure() => donne l'heure courante (de l'ordinateur) sous le format: "hh:mm:ss"'

sec2hms(sd) => donne l'heure en "hh:mm:ss.sss" à partir des secondes décimales.

cejour() => donne la date du jour sous le format: "jj/mm/aaaa".

bissextile(a) => dit si l'année donnée "a" est bissextile ou non.

nbjoursan(a) => donne le nombre de jour de l'annee "a".

numjouran(D) => donne le numéro du jour dans l'année d'une date D 'j/m/a' (1er janvier = 1, ...).

datenumjouran(n,a) => donne la date qui est le nième jour de l'année "a".

diffdate(D1,D2) => donne le nombre de jours entre 2 dates (format 'j/m/a'). Si D2 postérieure ou égale a D1, renvoie un nb positif ou nul. Sinon, renvoie un nb négatif.

adddate(D,n) => donne la date qui est postérieure de n jours à la date D 'j/m/a', ou anterieure de n jours si n<0.

numjoursem(D) => donne le numéro du jour de la semaine d'une date D 'j/m/a' (lundi=1, ...).

joursem(D) => donne le jour de la semaine d'une date D 'j/m/a' ('lundi' pour lundi, ...).

lundi(D) => trouve la date du lundi d'une semaine qui contient une date D 'j/m/a'.

paques(an) => trouve la date de Pâques d'une année donnée "an" par la méthode Hodges (validité: calendrier grégorien de 1593 à 4100). Vérification a été faite (par programme) avec toutes les dates officielles. Pour plus d'infos sur l'algorithme, voir http://users.chariot.net.au/~gmarts/eastalg.htm#EasterHodges .

ascension(an) => trouve la date du jeudi de l'ascension (paques + 39j).

pentecote(an) => trouve la date du dimanche de la pentecote (paques + 49j).

mardigras(an) => trouve la date du mardi gras (paques - 47j).

rameaux(an) => trouve la date du dimanche des rameaux (paques - 7j).

feries(an,sd=0) => renvoie la liste des jours fériés (France) de l'année donnée en 1er paramètre.

• si pas de 2ème paramètre (optionnel), les samedis et dimanches sont exclus

• en mettant 1 comme 2ème paramètre, on a tout (samedi et dimanche inclus)

• en mettant 2 comme 2ème paramètre, on a, en plus, les 2 jours fériés d'Alsace-Moselle (Vendredi saint et St Etienne=lendemain de Noël)

• => A adapter selon votre situation, région, pays, besoins et évolution de la législation.