Manuel d'utilisation de la CALCULEXT
version 1.40 [Tyrtamos - juin 2008]
Sommaire
Ce manuel est commun aux 3 versions de la Calculext::
La Calculext installable sur ordinateur
La calculext est une "calculatrice scientifique facilement extensible par l'utilisateur", 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 fonctionne de la même façon sur Windows et sur Linux, et c'est le même programme pour les 2 OS. Elle semble aussi fonctionner sur mac avec le même Python téléchargé (mais pas avec le Python du mac).
Elle est programmée dans le langage Python, et vous avez droit à toutes les possibilités de calcul d'expressions de Python (=tout ce que la fonction "eval()" peut supporter). Reportez-vous au manuel Python pour plus d'info.
Ce manuel traite aussi des nombreuses fonctions additionnelles (et optionnelles) que je vous propose et que vous ne trouverez pas dans les manuels python.
La Calculext installable disponible en version .exe pour Windows a des possibilités de calcul identiques. Son avantage est de ne pas nécessiter la présence de l'interpréteur Python. Cependant, les modifications de cette version exe nécessiteront:
La version dérivée de la Calculext, en ligne sur le web
Pour utiliser la version en ligne, il suffit d'avoir une connexion internet et d'appeler dans un navigateur web: http://calculext.jpvweb.com/.
Elle dispose des mêmes modules et fonctions additionnelles que la Calculext. Elle a cependant quelques limitations:
Je ne diffuse pas le code source de la version en ligne pour des raisons de sécurité réseau. Mais vous pouvez faire la vôtre en vous inspirant des explications ici: http://python.jpvweb.com/mesrecettespython/mini_calculatrice_cgi et en ajoutant les modules additionnels livrés avec la Calculext installable.
Amusez-vous bien!
Pour la Calculext installable (y compris pour son téléchargement): http://python.jpvweb.com/mesrecettespython/calculext
Pour utiliser la version dérivée de la Calculext en ligne sur le web: http://calculext.jpvweb.com/
Pour les explications sur la plupart de ses fonctions additionnelles: http://python.jpvweb.com/
Pour les fonctions courantes du langage python, vous pouvez avoir des infos complémentaires ici:
Pour le developpement de fonctions supplémentaires:
Fonctionnement de la calculext
La Calculext installable sur ordinateur
Lancement de la Calculext
Quand on lance la calculatrice, elle prend en compte le répertoire courant, c'est à dire le répertoire à partir duquel on l'a lancé. Cela permet à plusieurs utilisateurs d'utiliser la Calculext sur des données personnelles, et même pour linux, de l'utiliser en même temps (puisque Linux est multi-utilisateurs et pas seulement multi-tâches).
Exécution de calculs
La Calculext dans sa version installable sur ordinateur 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, avec toutes les facilités habituelles d'édition, y compris le copier-coller. Attention, pour les nombres décimaux, la virgule est toujours remplacée par un "point décimal" (à l'anglo-saxonne).
Un clic droit de souris sur la zone de saisie (shift-clic gauche sur le mac) 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. Et si vous aviez sélectionné avant une zone de texte, elle se trouve à l'intérieur des parenthèses après insertion.
L'exécution est lancée par le menu "Calculer" ou par la touche de clavier "retour". (clavier normal ou clavier numérique).
Quelque soit le résultat:
L'effacement des 3 zones (saisie, résultat et durée du calcul) peut être obtenu par le menu "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.
Une fois lancé, le calcul s'exécute en tâche de fond, et peut être interrompu s'il dure trop longtemps (menu “stopper” ou touche [F2]). Cependant, les opérations d'affichage sur des données très très longues (par exemple 50000 caractères) peuvent durer plusieurs minutes et ne peuvent être interrompues.
Arrêt normal de la calculette par:
On peut arrêter la calculatrice, même si un calcul long est en cours (il est bien sûr perdu...).
Changement du répertoire de travail
On fait cela avec le menu Fichier:
Sauvegardes et recharge de données
On fait cela avec le menu Fichier: Tous les échanges avec le disque se fait dans le répertoire de travail.
Avoir de l'aide
On fait cela avec le menu "Aide":
Idem avec la touche de clavier F1.
Il y a aussi possibilité d'avoir une information sur une fonction donnée en exécutant dans la calculatrice: "aide(nom_de_la_fonction)".
La version dérivée de la Calculext, en ligne sur le web
Dans un navigateur web quelconque (ie, firefox, opera, konqueror, ...), appel de la calculatrice par: http://calculext.jpvweb.com.
On écrit l'expression à calculer dans la zone de saisie. On dispose de toutes les facilités d'édition habituelles, y compris le copier-coller et le glisser-déposer avec la souris.
On lance le calcul par la touche "Entrée" du clavier, ou par le bouton "Calculer" de la page.
Il s'affiche alors le rappel de l'expression, le résultat calculé et le temps de calcul.
La présente aide est obtenue en cliquant sur l'hyperlien correspondant.
Vous pouvez utiliser le menu avec la souris pour insérer des fonctions dans la zone de saisie sans avoir à les taper. De plus, la lecture du menu vous rappelle les fonctions disponibles, avec leurs paramètres. Enfin, si vous avez sélectionné du texte avant d'insérer une fonction du menu ayant des parenthèses, le texte sélectionné viendra entre ces parenthèses.
Par exemple, pour changer l'affichage des nombres réels, sélectionnez tout le texte que vous avez et insérez arrond() avec le menu. Il ne vous reste plus qu'à mettre avant la parenthèse finale, par exemple, ",4" pour avoir un affichage avec 4 chiffres après la virgule.
Booléen (type bool)
Un booléen est une donnée qui ne peut prendre que 2 valeurs: True (=vrai) et False (=faux). Ne pas oublier que la 1ère lettre est en majuscule
Dans la calculatrice, on peut calculer le résultat d'expression booléennes. Par exemple::
|
1==1 => True 1==2 => False 2<3 => False |
Certaines fonctions additionnelles renvoient un résultat booléen comme la fonction qui dit si une année est bissextile:
|
bissextile(2008) => True |
Cela permet de faire des calculs logiques aussi complexe que vous voulez avec des opérateurs comme "and" (=et), "or" (=ou), "not" (=non) et les opérateurs de comparaison habituels: "==", ">", ">=", "<", "<=", "!=".
Nombre entier (type int)
Un entier est un nombre composé uniquement de chiffres, sans virgule ni exposant. Exemples: 12 785 5 99
Un entier est en général compris entre -231 et 231-1 (cela dépend de la machine dont vous disposez)
Vous pouvez calculer cela avec la calculatrice: 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:
|
maxint => 2147483647 |
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":
|
123456789L |
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 :
|
2**1000 |
qui renvoie (sur une seule ligne!):
|
107150860718626732094842504906000181056140481170553360744375038837035105 112493612249319837881569585812759467291755314682518714528569231404359845 775746985748039345677748242309854210746050623711418779541821530464749835 819412673987675591655439460770629145711964776865421676604298316526243868 37205668069376L |
Vous récupérez le résultat par copier-coller ou, sur la Calculext installable, avec la copie du résultat dans le menu "Fichier".
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:
La calculette donne toutes les possibilités de conversion dans les 2 sens:
|
oct(123) donne 0173 0173 donne 123 (NB: un entier avec un zéro devant est toujours pris pour un nombre octal)
hex(123) donne 0x7B 0x7B donne 123 (NB: un entier avec "0x" devant est toujours pris pour un nombre hexadécimal)
|
Pour les conversions en binaire (module additionnel "conversions"):
|
dec2bin(123) donne "1111011" dec2bin(123,16) donne "0000000001111011" (le 2ème paramètre facultatif =16 donne la taille du mot: 16 bits) dec2bins(-91,12) donne "111110100101" (conversion en binaire signé (complément à 2) pour un mot de 12 bits).
bin2dec("1111011") donne 123. bin2decs("111110100101") donne -91 (conversion en binaire signé (complément à 2)).
dec2gray(123) donne "01000110" gray2dec("01000110") donne 123
|
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:
|
dec2bin(78965412356894213) donne "100011000100010101001111111001001000100110010111000000101" |
Conversion avec les caractères (très pratique pour les informaticiens!)
|
ord("A") donne 65, valeur ascii du caractère "A" hex(ord("A")) donne la même chose, mais en hexa: '0x41' chr(65) ou chr(0x41) donne 'A' = le caractère dont le nombre ascii est 65 (ou 0x41 en hexa). |
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+308
Dans la calculatrice, 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 les ordinateurs. Il est possible d'obtenir un autre affichage au coup par coup grâce à la fonction arrond() (voir ci-dessous le chapitre qui traite des nombres réels).
Sur la calculext installable, l'utilisateur peut changer le mode d'affichage des nombres réels, grâce à la fonction "precision(n)", selon la valeur de n entre -17 et +17: Exemple:
|
precision(2) => toutes les expressions suivantes seront affichées avec 2 chiffres après la virgule precision() ou precision(-15) => retour à l'affichage par défaut |
Cet affichage fonctionne aussi:
On peut obtenir le même effet ponctuellement, c'est à dire sans changer le mode courant d'affichage, avec la fonction arrond(x,n). Exemple:
|
arrond(0.1,4) => affiche "0.1000" sans changer le mode d'affichage des expressions suivantes |
Avec la calculatrice en ligne, on ne peut changer l'affichage qu'à l'intérieur d'une liste de calcul, puisqu'il n'y a pas de mémoire d'un calcul à l'autre. Par exemple (on utilise ici une fonction du module additionnel "credit"):
|
[precision(2),menscredit(1000,5,12),menscredit(1000,5,24),menscredit(1000,5,36)] => [2,85.61,43.87,29.97] |
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:
|
complex(1,2)+complex(2,3) => (3+5j) complex(-2,5)*complex(1,-3) => (13+11j) complex(3,1)/complex(-2,-5) => (-0.379310344827586+0.448275862068966j) (en fait, avec le calcul à la main, on trouve (-11/29 + 13/29j)) |
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::
|
sto("x",complex(1,2)) => (1,2j) sto("y",complex(2,3)) => (2+3j) x+y => (3+5j) |
Sur la calculatrice en ligne, l'exemple qui précède n'est valable que dans une liste de calculs enchaînés puisqu'il n'y a pas de mémoire d'un calcul à l'autre:
|
[sto("x",complex(1,2)),sto("y",complex(2,3)),x+y] => [(1+2j),(2+3j),(3+5j)] |
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:
|
cmath.sin(complex(3,1)) => (0.217759551622152-1.16344036370325j) (notez le pré-fixage de la fonction sinus avec "cmath.") |
Liste non commentée des fonctions du module "cmath" dédiées aux nombres complexes:
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 bool -> 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:
|
long(n) transforme n en type long int(n) transforme n en type entier (int) float(n) transforme n en type réel (float) bool(n) vaut "False" si n=0, et "True dans n'importe quel autre cas. complex(n) transforme n en type complexe (complex). Ex: complex(5) -> (5,0j). complex(nr,ni) transforme le couple "nr" et "ni" en type complexe (complex). Ex: complex(5,6) -> (5,6j) |
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 chiffres, 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:
|
precisiondecimal(28) => permet de fixer la précision de calcul (28 chiffres, c'est la précision par defaut) Decimal("3.333333333333333333333333333")+Decimal("0.000000000000000000000000001") => Decimal("3.333333333333333333333333334") |
Actuellement, même pour la calculext installable, les changements de precision ne peuvent se faire que dans une liste de calculs enchaînés (à cause du calcul par thread) comme:
|
[precisiondecimal(5),Decimal("10")/3] => [5,Decimal("3.3333")] |
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:
|
bin2dec("100101001110") => 2382 (fonction du module additionnel "bibgene") cejour() => "09/04/2008" (fonction du module additionnel "temps") |
Listes (type list)
Une liste est un assemblage de plusieurs objets (expression ou valeurs), séparés pardes virgules et entourés par des crochets. Par exemple, [2, 3.7, sin(0.2), 99/7].
Python est très doué pour manipuler les listes.
Qu'est-ce que ça vient faire dans une calculatrice? Et bien, 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:
|
facteurs(56987124) => [2, 2, 3, 47, 79, 1279] |
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):
|
deg2dms(45.0) => [45, 0, 0.0] conversion d'un angle en degrés décimaux => [degré,minutes,secondes] dms2deg([45, 0, 0.0]) => 45.0 convertion d'un angle en [degré,minutes,secondes] => degrés décimaux ce qui permet: dms2deg(deg2dms(45.0)) => 45.0 |
Vous pouvez manipuler les listes:
|
sto("x",facteurs(56987124)) => [2, 2, 3, 47, 79, 1279] |
|
x[0] => 2 x[2] => 3 x[-2] => 79] avec un indice négatif, on renvoie les valeurs à partir de la fin x[1:4] => [2,3,47] renvoie la liste des valeurs de 1 à 4 (4 exclu) len(x) => 6 nombre de valeurs de la liste x.append(55) => [2, 2, 3, 47, 79, 1279, 55] ajoute 55 à la liste x etc... Voir le manuel python |
On peut avoir des listes de n'importe quoi, y compris des listes de chaînes ou même des listes de listes, ce qui permet de représenter des arbres.
Fonctions de base de la calculette
Fonctions pour avoir de l'aide
Pour avoir l'aide générale (=la présente page):
Pour avoir l'aide sur une fonction en particulier, calculez "aide(nomdelafonction)".
Par exemple:
|
aide(sin) => "sin(x) Return the sine of x (measured in radians)." |
NB: l'aide pour les fonctions intégrées "python" est en anglais
|
aide(bissextile) => "bissextile(a): dit si l'année donnée est bissextile ou non (True=oui, False=non)" |
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 ;-) ):
|
aide(aide) => "aide(fn): affiche l'aide sur une fonction donnée fn" |
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:
|
sto("toto",5/cos(0.3654)) => 5.35342849518736 |
Comme la fonction "sto" renvoie la valeur de l'expression, vous pouvez l'utiliser à l'intérieur d'une autre expression:
|
2/cos(0.78)*sto("toto",2**3)+5 => 27.5062530736666 |
Après cette expression, vous pouvez utiliser directement la variable toto dans un autre calcul. Sa valeur 2**3 => 8 sera utilisée:
|
2*toto => 16 |
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:
|
sto("toto", "bonjour tout le monde") => 'bonjour tout le monde' sto("toto", True) => True sto("toto", [4, 55, 99, 6]) => [4, 55, 99, 6] sto("toto", 45893271002598563254L) => 45893271002598563254L etc... |
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.
Dans la calculatrice en ligne, ce qui précède n'est valable que dans une liste de calculs enchaînés. Par exemple:
|
[sto("x",2*cos(0.123)),sto("y",sin(0.789)),x*y] => [1.98489006427039,0.709649072042656,1.40857539221617] |
A noter que si c'est seulement le dernier résultat qui vous intéresse, il suffit d'ajouter [-1] après la liste des expressions, et vous n'aurez plus que 1.40857539221617 comme résultat.
Fonctions intégrées de calcul d'expression
Constantes mathématiques prédéfinies
pi => le nombre "pi", constante mathématique, rapport de la circonférence d'un cercle sur son diamètre
|
pi => 3.1415926535897931 |
e => le nombre "e", constante mathématique, base des logarithmes naturels
|
e => 2.7182818284590451 |
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 ici décimales et non entières! Par exemple: 10/3 donnera bien "3.33333333333333" et non 3.
|
10/3 => 3.33333333333333 |
// = division avec troncature (ex: 10.0//3 => 3 au lieu de 3.33333333333333)
|
10.0//3 => 3 au lieu de 3.33333333333333 |
** = élévation à un puissance
|
2**3 => 8 |
pow(x,y) => idem à x**y
|
pow(2,3) => 8 |
% = fonction modulo = reste de la division entière
|
11%2 => 1 11-(11//2*2) => 1 |
( et ) = parenthèses: permettent de contraindre un ordre dans l'exécution des calculs (voir tableau de priorité des opérateurs).
|
2*(4+5) => 18 2*4+5 => 13 |
sqrt(x) => racine carrée de x
|
sqrt(2) => 1.4142135623731 |
exp(x) => e élevé à la puissance x
|
exp(2) => 7.38905609893065 e**2 => 7.38905609893065 |
floor(x) => arrondi à l'entier inférieur
|
floor(3.9) => 3 floor(-3.9) => -4 |
log(x) => logarithme népérien de x
|
log(e) => 1 |
log10(x) => logarithme base 10 de x
|
log10(10) => 1 |
abs(x) => donne la valeur absolue de x
|
abs(5) => 5 abs(-5) => 5 |
Opérateurs logiques
>, >=, <, <=, ==, != comparent 2 nombres et renvoient True (=vrai) ou False (=faux)selon le résultat
|
2==2 => True 2!=3 => True 2<3 => True 2>3 => False |
and fait un "et" booléen entre 2 états True et False (ex: True and True => True)
|
2==2 and 2<3 => True |
or fait un "ou" booléen entre 2 états True et False (ex: True or False => True)
|
2==3 or 2<3 => True |
not fait un "non" booléen (ex: not True => False)
|
not 2<3 => False |
Opérateurs binaires
"&" permet un "et" bit à bit:
|
& |
0 |
1 |
|
0 |
0 |
0 |
|
1 |
0 |
1 |
Exemple:
|
2&6 => 2 (2 = "00000010") et 6 = "00000110" alors 2&6 = "00000010") |
"|" pemet un "ou" bit à bit.
|
| |
0 |
1 |
|
0 |
0 |
1 |
|
1 |
1 |
1 |
Exemple:
|
2|6 => 6 (2 = "00000010") et 6 = "00000110" alors 2|6 = "00000110") |
"^" permet un "ou" exclusif bit à bit.
|
^ |
0 |
1 |
|
0 |
0 |
1 |
|
1 |
1 |
0 |
Exemple:
|
2^6 => 4 (2 = "00000010") et 6 = "00000110" alors 2^6 = "00000100") |
"~" fait un "non" bit à bit Exemple:
|
~6 => -7 en entier signé. en fait: 6 = "00000110" et ~6 = "11111001" = 249 en entier non signé |
"<<" et" >>" font des décalages de bits à gauche et à droite. Exemple:
|
8>>1 => 4 8>>2 => 2 8<<1 => 16 |
Priorité décroissante des opérateurs
(la même liste se trouve dans le menu flottant)
|
`xxxxxx` |
évaluation de chaîne |
| {clé:donnée, ...} | dictionnaire |
|
[1,2,3,...] |
liste |
|
() |
parenthèses ou tuple |
|
f() |
appel de fonction |
|
x[i1:i2] |
découpage de séquences |
|
x[i] |
indexation de séquences |
| xxx.attribut | reférence |
|
** |
puissance (ex: 2**3 => 8) |
|
~ |
"non" binaire |
|
+, - |
positif, négatif (ex: -2, +5) |
|
*, /, //, % |
mult., div., div entière, modulo |
|
+, - |
addition, soustraction |
|
<<, >> |
décalage binaire |
|
& |
"et" binaire |
|
^ |
"ou exclusif" binaire |
|
| |
"ou" binaire |
|
<, <=, >, >=, !=, == |
comparaisons |
|
is, not is |
test d'identité |
|
in, not in |
test d'appartenance |
|
not x |
"non" logique |
|
and |
"et" logique |
|
or |
"ou" logique |
|
lambda |
expression lambda |
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:
|
sin(0.25698)*1/sqrt(2*pi)*log(1.25698)**(1.6987) => 0.00827261825741359 |
Vous voulez calculer cette fonction avec d'autres valeurs que 0.25698 (qui intervient à 2 endroits) et 1.6987. Vous faites:
|
sto("mafonction",lambda x,y: sin(x)*1/sqrt(2*pi)*log(1.25698)**(y)) |
Désormais, vous pouvez calculer:
|
mafonction(0.25698,1.6987) => 0.00827261825741359 mafonction(0.65423,1.7298) => 0.0189192228012913 mafonction(1.9875,1.0749) => 0.0747066661174212 mafonction(2.86278,0.0749) => 0.0983086841243615 etc... |
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…:
|
map(sin,[0.1, 0.2, 0.3, 0.4, 0.5]) => [0.0998334166468282,0.198669330795061,0.29552020666134,0.389418342308651,0.479425538604203] |
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):
|
map(paques,jeuxdessais(5,2008,2012)) => ['23/03/2008', '12/04/2009', '04/04/2010', '24/04/2011', '08/04/2012'] |
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:
|
sto("f",lambda y: y>=100) |
Et on cherche la liste des nombres premiers compris entre 100 et 200:
|
filter(f,premiers(200)) => [101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199] |
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:
|
[sto("f",lambda y: y>=0),filter(f,hgaussred(10))] -> [0.70683994795139,0.139106211249837,0.517782930504369,0.222072398717544,0.578393938896522] |
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:
|
[3*x for x in range(0,10) if x%2==0] => [0,6,12,18,24] |
Dans cette expression:
La condition avec "if" est optionnelle. Par exemple: les 5 prochaines dates de Pâques:
|
[paques(x) for x in range(2008,2013)] => ["23/03/2008","12/04/2009","04/04/2010","24/04/2011","08/04/2012"] |
On peut, bien sûr, combiner toutes ces fonctions: sto, lambda, map, filter, compréhension de liste, etc... pour obtenir ce qu'on veut.
Exécution conditionnelle de type if-then-else
Vous ne pouvez pas utiliser directement if-then-else dans la calculatrice, parce que "if" est une instruction, et pas un opérateur de calcul.
Par contre, vous pouvez utiliser l'une des 2 solutions suivantes pour simuler le if-then-else:
|
(2*3 if 2<3 else 3*4) => 6 (2*3 if 2>3 else 3*4) => 12 |
|
(2<3 and [2*3] or [3*4])[0] => 6 (2>3 and [2*3] or [3*4])[0] => 12 |
Ce qui donne, bien entendu, le même résultat. C'est seulement un peu moins lisible.
A noter que vous pouvez utiliser ces solutions dans une fonction lambda.
Fonctions des modules additionnels
Module "bibgene"
Bibliothèque générale / fonctions diverses
jeuxdessais(n,L1,L2): construit une liste de n jeux de paramètres commençant à L1 et se terminant à L2.
|
jeuxdessais(10,0,9) => [0,1,2,3,4,5,6,7,8,9] |
|
jeuxdessais(3,[1,2,3],[3,4,5]) => [[1,2,3],[2,3,4],[3,4,5]] |
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:
|
sto("X",lambda L: L[0]+L[1]+L[2]) |
Et on va utiliser la fonction python “map()” pour appliquer ces jeux de paramètres à la fonction X:
|
map(X, jeuxdessais(5,[1,2,3],[3,4,5])) => [6,7.5,9,10.5,12] |
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?
|
volcuve(40,120,3500) => 1021.26992026825 |
Remarques:
triliste(L,direct=True) = renvoie la liste L triée par ordre alphanumérique: Si le 2ème paramètre est False, la liste est triée à l'envers.
|
triliste(['b','a','d','c']) => ["a","b","c","d"] triliste([5,4,9,1,0]) => [0,1,4,5,9] triliste([5,4,9,1,0],False) => [9,5,4,1,0] |
fnimplicite(fn,x1,dx,eps=1.0e-15) = résolution d'une équation implicite par recherche du zéro d'une fonction.
Voilà encore une fonction rare sur une calculatrice. Prenons un exemple. J'ai une expression a*x + b*x**2 + c/x**3 = 0 avec a=0.509637427336286, b=-0.365419816785096 et c=0.0936145349893529. Je voudrais calculer x, mais je ne sais pas modifier l'expression pour avoir x=f(). Il s'agit d'une équation implicite, et il faut trouver x tel que f(x)=0. Voilà ce qu'on va faire:
|
f=lambda x: 0.509637427336286*x+0.365419816785096*x**2+0.0936145349893529/x**3 fnimplicite(f,1,0.1) => affiche: 1.4522568370062716 |
Vous pouvez vérifier:
|
f(1.4522568370062716) # affiche 6.34908792208e-016 qui est bien < 1.0e-15 |
Donc, vous donnez à cette fonction fnimplicite(fn,x1,dx,eps=1.0e-15) les paramètres suivants:
Particularité de cette fonction, elle trouvera le zéro même si vous lui avez donné une mauvaise direction de recherche. Par exemple, on cherche la valeur de x qui annule la fonction sin(), mais on donne comme point de départ x=pi/4 radians (=45°) et un incrément de 0.1 radian. Cette fonction trouvera x=0 et non x=pi. Pour trouver pi, il faudra commencer à pi/2. Si vous voulez une fonction de recherche qui ne cherche que dans un seul sens, prenez la suivante fnimplicite2():
|
fnimplicite(sin,pi/4,0.1) => 0 fnimplicite(sin,pi/2,0.1) => 3.14159265358979 |
Si vous essayez avec une fonction qui ne s'annule jamais, par exemple:
|
sto("f",lambda x: 1+x**2) fnimplicite(f,2,1) |
cela affichera, puisqu'il n'existe aucune valeur de x capable d'annuler 1+x**2:
|
erreur fnimplicite(fn,x1,dx,eps=1.0e-15): impossible de trouver le zero de cette fonction |
Avec la Calculext en ligne, il faudra enchaîner les calculs dans une liste, par exemple (le dernier "[1]" permet de n'avoir que le dernier résultat):
|
[sto("f",lambda x: 5*x**2),fnimplicite(f,2,1)][1] => 0 |
fnimplicite2(fn,x1,dx,eps=1.0e-15) = résolution d'une équation implicite par recherche du zéro d'une fonction sans changement de sens
C'est la même chose que la fonction précédente, à part qu'elle ne cherche que dans la direction donnée par le signe de l'incrément, et qu'elle ne change pas de sens pendant la recherche. Pour reprendre l'un des exemples précédents:
|
fnimplicite2(sin,pi/4,0.1) => 3.14159265358979 fnimplicite2(sin,pi/4,-0.1) => 0 |
Module conversions
dec2bin(d, nb=0) convertit un entier en nombre binaire (=chaîne de caractère).
|
dec2bin(63) => "111111" |
On peut ajouter comme 2ème paramètre la taille du mot en nombre de bits, auquel cas la fonction ajoute si nécessaire des "0" à gauche pour arriver à la longueur voulue:
|
dec2bin(63,8) => "00111111" |
dec2bins(d, nb=0) convertit un nombre entier signé en nombre binaire signé par la méthode du complément à 2.
|
dec2bins(63) => 0111111 dec2bins(-63) => "11000001" |
Sans le 2ème paramètre nb, la conversion est faite en tenant compte du nombre de bits minimum nécessaire pour représenter ce nombre, y compris le bit de signe à gauche ("0" pour d>=0 et "1" pour d<0).
Avec le 2ème paramètre, la fonction complète à gauche si nécessaire selon le signe du nombre d, le dernier bit à gauche étant le bit de signe:
|
dec2bins(-63,16) => "1111111111000001" |
bin2dec(C) convertit un nombre binaire en entier décimal (ne pas oublier les guillemets autour du nombre binaire: c'est une chaîne!)
|
bin2dec("0111111") => 63 |
bin2decs(C) convertit un nombre binaire signé en entier décimal signé (ne pas oublier les guillemets!) par la méthode du complément à 2.
|
bin2decs("11000001") => -63 bin2decs("1111111111000001") => -63 |
deg2dms(DD) convertit des degrés décimaux en une liste [degrés, minutes, secondes].
|
deg2dms(50.75) => [50,45,0] |
dms2deg(L) convertit une liste [degrés, minutes, secondes] en degrés décimaux.
|
dms2deg([50,45,0]) => 50.75 |
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:
|
mdp2hex("MotDePasse789") => "4d6f7444655061737365373839" |
hex2mdp(ch): Convertit en texte clair les mots de passe donnés en séquence hexadécimale. Exemple:
|
hex2mdp("4d6f7444655061737365373839") => "MotDePasse789" |
dec2gray(n,nb=8): Génère le code de Gray (représentation binaire) correspondant au nombre entier n. Le paramètre optionnel représente le nombre de bits. Exemple:
|
dec2gray(10) => "00001111" dec2gray(10,16) => "0000000000001111" |
gray2dec(ch): . Retrouve le nombre entier auquel correspond le code de Gray donné sous forme de chaîne binaire. Exemple:
|
gray2dec("00001111") => 10 |
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:
|
fact(50) => 30414093201713378043612608166064768844377641568960512000000000000L |
En quelques secondes, on peut aussi calculer fact(20000) qui comporte tout de même 77338 chiffres! Mais ce nombre est tellement long que la Calculext sous Windows refusera de l'afficher. Vous pouvez cependant le sauvegarder sur disque.
pgcd(a,b) = PGCD de a et b => Plus Grand Commun Diviseur des 2 nombres entiers (>0) a et b.
|
pgcd(1071,1029) => 21 |
ppcm(a,b) = PPCM de a et b => Plus Petit Commun Multiple des 2 nombres entiers (>0) a et b.
|
ppcm(60,168) => 840 |
facteurs(n) = décomposition en facteurs premiers => renvoie la liste des facteurs premiers trouvés.
|
facteurs(789456123) => [3,3,6343,13829] |
estpremier(n) = teste si le nombre entier "n" est premier ou non => renvoie True s'il l'est et False sinon.
|
estpremier(999983) => True (calcul fait en moins d'une milliseconde) |
premiers(n) = calcule tous les nombres premiers inférieurs ou égaux à n => renvoie la liste.
|
premiers(100) => [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97] |
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.
|
permut(3) => 6 |
permutliste(L,r=0) = donne la liste de toutes les permutations d'une liste de chaîne. Exemple:
|
permutliste(['A','B','C']) => [["B","A","C"],["B","C","A"],["C","B","A"],["C","A","B"],["A","C","B"],["A","B","C"]] |
Si r=1 => élimine les redondances dans le résultat. Ces redondances apparaissent dans le résultat quand plusieurs éléments de la liste sont identiques:
|
permutliste(['A','B','B'],1) => [["B","A","B"],["B","B","A"],["A","B","B"]] |
Si vous voulez rendre votre liste de résultats plus présentable, il suffit de la trier avec la fonction triliste() du module bibgene:
|
triliste(permutliste(['A','B','C'])) => [["A","B","C"],["A","C","B"],["B","A","C"],["B","C","A"],["C","A","B"],["C","B","A"]] |
Application amusante. Rappelez-vous le bourgeois gentilhomme de Molière qui tournait dans tous les sens la phase "Belle Marquise, vos beaux yeux me font mourir d'amour". Et bien, vous pouvez maintenant calculer toutes les phrases possibles construites avec ces 9 mots. Mais soyez patient, il y en a tout de même 362880, et la calculatrice les donnera toutes, y compris celles qui n'ont aucun sens. Cela demande près de 2 heures de calcul, le résultat ne s'affiche que sur linux, et après sauvegarde sur disque, produit un fichier de 25,3 Mo...
permutchaine(ch,r=0) = donne la liste de toutes les permutations des caractères d'une chaîne de caractère. Exemple:
|
permutchaine("ABC") => ["BAC","BCA","CBA","CAB","ACB","ABC"] |
Si r=1 => élimine les redondances dans le résultat
|
permutchaine("ABB") => ["BAB","BBA","ABB"] |
Si vous voulez rendre votre liste de résultats plus présentable, il suffit de la trier avec la fonction triliste() du module bibgene:
|
triliste(permutchaine("ABC")) => ["ABC","ACB","BAC","BCA","CAB","CBA"] |
Cette fonction permutchaine() permet des choses étonnantes, comme d'établir la liste de toutes les positions possibles de k bits "1" dans un mot de n bits. Par exemple:
|
triliste(permutchaine("11000",1),False) => ["11000","10100","10010","10001","01100","01010","01001","00110","00101","00011"] |
arrang(n, k) = nombre d'arrangements de n objets pris k à k, en tenant compte de l'ordre, c'est à dire que "AB" et "BA "sont deux cas différents .
|
arrang(10,2) => 90 |
arrangliste(L,k) = donne la liste de tous les arrangements de n objets (=dans une liste L) pris k à k:
|
arrangliste(["A","B","C"],2) => [["B","A"],["A","B"],["C","A"],["A","C"],["C","B"],["B","C"]] |
Et en triant:
|
triliste(arrangliste(["A","B","C"],2)) => [["A","B"],["A","C"],["B","A"],["B","C"],["C","A"],["C","B"]] |
arrangchaine(ch,k) = donne la liste de tous les arrangements de n objets (=caractères de la chaîne ch) pris k à k
|
arrangchaine("ABC",2) => ["BA","AB","CA","AC","CB","BC"] |
et, en triant:
|
triliste(arrangchaine("ABC",2)) => ["AB","AC","BA","BC","CA","CB"] |
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"
|
combin(10,2) => 45 |
A noter que nous avons, bien entendu:
|
arrang(10,2)/permut(2) = combin(10,2) = 45 |
combinliste(L,k) = donne la liste de toutes les combinaisons de n objets (=dans une liste L) pris k à k
|
combinliste(["A","B","C"],2) => [["A","B"],["A","C"],["B","C"]] |
Si la liste n'est pas assez "présentable", on peut bien sûr la trier avec triliste().
combinchaine(ch,k) = donne la liste de toutes les combinaisons de n objets (=caractères de la chaîne ch) pris k à k
|
combinchaine("ABC",2) => ["AB","AC","BC"] |
Si la liste n'est pas assez "présentable", on peut bien sûr la trier avec triliste().
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..
|
binom(2,10,0.2) => 0.301989888 |
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.
|
binomcum(2,10,0.2) => 0.6777995264 |
Ce qui correspond à: binom(0,10,0.2)+binom(1,10,0.2)+binom(2,10,0.2)
binomconfsup(k,n,conf) = pour une distribution binomiale, donne la borne supérieure de confiance sur la proportion donnée par un échantillon (k,n) avec une confiance conf
|
binomconfsup(3,30,0.975) => 0.26528844833374 |
Interprétation: j'ai trouvé 3 billes vertes dans un échantillon de 30 billes, et j'ai envie de dire qu'il y en a 10% dans la population. En fait, il pourrait y en avoir jusqu'à 26,5% avec un risque de 2,5% que je me trompe (c'est à dire qu'il y en ait encore plus).
binomconfinf(k,n,conf) = pour une distribution binomiale, donne la borne inférieure de confiance sur la proportion donnée par un échantillon (k,n) avec une confiance conf
|
binomconfinf(3,30,0.975) => 0.0211171388626099 |
Interprétation: j'ai trouvé 3 billes vertes dans un échantillon de 30 billes, et j'ai envie de dire qu'il y en a 10% dans la population. En fait, il pourrait y en avoir jusqu'à 2,1% avec un risque de 2,5% que je me trompe (c'est à dire qu'il y en ait encore moins).
binomconf(k,n,conf) = pour une distribution binomiale, donne les 2 bornes inférieure et supérieure de confiance sur la proportion donnée par un échantillon (k,n) avec une confiance conf
|
binomconf(3,30,0.95) => [0.0211171388626099,0.26528844833374] |
Vous voyez qu'on obtient les 2 bornes inférieures et supérieure calculées précédemment, à part qu'un risque de 2,5% que la valeur soit inférieure à la borne inférieure et 2,5% qu'elle soit supérieure à la borne supérieure, ç a fait bien un risque de 5% et donc une confiance de 95%
hbinom(n,p,nb=0) = donne une valeur ou une liste de valeurs tirée(s) au hasard selon une distribution binomiale.
Par exemple, je simule le prélèvement de 50 pièces dans un lot qui comporte 1,5% de pièces défectueuses. Voilà le nombre de pièces défectueuses que je peux avoir dans mon prélèvement de 50 pièces, renouvelé 10 fois:
|
hbinom(50,0.015,10) => [2,0,1,1,0,0,0,1,2,3] |
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 dans un jeu de carte, la probabilité d'avoir k=3 coeurs dans une main de n=5 cartes, sachant qu'il y a g=13 coeurs dans le jeu de t=52 cartes est:
|
hypgeo(3,5,13,52) => 0.0815426170468187 |
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 ou 3 coeurs dans la main de 5 cartes
|
hypgeocum(3,5,13,52) => 0.988775510204082 |
Cela correspond, bien entendu, à: hypgeo(0,5,13,52)+hypgeo(1,5,13,52)+hypgeo(2,5,13,52)+hypgeo(3,5,13,52)
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.
poisson(k,m) = probabilité d'avoir k évènements distribués selon une loi de Poisson de paramètre m
Exemple: probabilité d'avoir 4 accidents en 1 mois, alors que d'habitude j'en ai 2 en moyenne:
|
poisson(4,2) => 0.0902235221577418 soit environ 9% |
poissoncum(k,m) = probabilité d'avoir 0,1,..,k évènement(s) distribués selon une loi de Poisson de paramètre m
Exemple: probabilité d'avoir 0, 1 ou 2 défaut(s) dans une pièce de tissu qui en comporte 5 en moyenne
|
poissoncum(2,5) => 0.124652019483081 soit environ 12,5% |
poissonconfsup(k,conf) = Borne supérieure de confiance sur le paramètre m d'une distribution de Poisson
Exemple: j'ai eu 2 évènements distribués selon une loi de poisson. Avec cette fonction, je peux dire que son paramètre m est inférieur à 7.22, avec 2.5% de chances de me tromper (c'est à dire que le vrai m soit supérieur)
|
poissonconfsup(2,0.975) => 7.22468719482421 |
poissonconfinf(k,conf) = borne inférieure de confiance sur le paramètre m d'une distribution de Poisson
Exemple: j'ai eu 2 évènements distribués selon une loi de poisson. Avec cette fonction, je peux dire que son paramètre m est supérieur à 0,24, avec 2.5% de chances de me tromper (c'est à dire que le vrai m soit inférieur)
|
poissonconfinf(2,0.975) => 0.242209243774414 |
poissonconf(k,conf) = Intervalle de confiance sur le paramètre m d'une distribution de Poisson
Regroupement des 2 cas précédents: le paramètre cherché sera dans l'intervalle 0.24...7.22 avec une confiance de 95%. Dans 2.5% des cas, le vrai paramètre sera inférieur à la borne inférieure, et dans 2.5% il sera supérieur à la borne supérieure.
|
poissonconf(2,0.95) => [0.242209243774414,7.22468719482421] |
hpoisson(m,nb=0) = Génération de valeurs tirées au hasard selon une distribution de Poisson de paramètre m
Exemple: voilà 10 valeurs tirées d'une distribution de Poisson de paramètre m=2:
|
hpoisson(2,10) => [2,4,1,2,0,2,4,2,0,5] |
pgaussred(x) = probabilité qu'une variable aléatoire distribuée selon une loi normale réduite soit inférieure à x
|
pgaussred(2) => 0.977249865802215 |
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 7/100 seconde. Vous pouvez compter sur une précision d'au moins 5 ou 6 chiffres après la virgule. A partir de 7.56 é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.
|
pgauss(8,2,3) => 0.977249865802215 |
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)
|
xgaussred(0.977249865802215) => 2 (arrondi à 12 chiffres après la virgule) |
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
|
xgauss(0.977249865802215,2,3) => 8 (arrondi à 12 chiffres après la virgule) |
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.
|
hgaussred() => 0.567294449931055 hgaussred(5) => [1.32776690852703,1.27764227667921,-0.533627075302324,0.258655633309361,-1.76545189227476] |
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.
|
hgauss(2,3) => 4.03242270571878 hgauss(2,3,5) => [0.201618530765891,3.22913260911314,-0.842929170234812,4.07519103175748,7.25240024441201] |
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:
|
menscredit(1000,10,12) => 87.92 (arrondi à 2 chiffres après la virgule) |
Remarques:
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?
|
moiscredit(1000,10,87.92) => 12 (arrondi à 2 chiffres après la virgule) |
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?
|
capcredit(10,87.92,12) => 1000 (arrondi à zéro chiffres après la virgule) |
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?
|
intcredit(1000,50,24) => 18.15% |
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
|
coutcredit(1000,50,24) => 200 |
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):
|
coutcredit(1000,50,24,20) => 220 |
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:
|
coutcredit(1000,50,24,20)/1000*100 => 22% |
Module "temps"
tempsordi() => donne la date et l'heure de l'ordinateur avec le jour de la semaine (en français) sous le format.
|
tempsordi() => "mercredi 30/04/2008 15:01:21" |
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.
|
tempsntp() => "mercredi 30/4/2008 15:3:31" |
cetteheure() => donne l'heure courante (de l'ordinateur) sous le format: "hh:mm:ss"'
|
cetteheure() => "19:17:29" |
sec2hms(sd) => donne l'heure en "hh:mm:ss.sss" à partir des secondes décimales.
|
sec2hms(84125.321456) => "23:22:05.321" |
cejour() => donne la date du jour sous le format: "jj/mm/aaaa".
|
cejour() => "27/01/2008" |
bissextile(a) => dit si l'année donnée "a" est bissextile ou non.
|
bissextile(2008) => True bissextile(2009) => False |
nbjoursan(a) => donne le nombre de jour de l'annee "a".
|
nbjoursan(2007) => 365 nbjoursan(2008) => 366 |
numjouran(D) => donne le numéro du jour dans l'année d'une date D 'j/m/a' (1er janvier = 1, ...).
|
numjouran("11/11/2007") => 315 numjouran(cejour()) => 121 (c'était le 30/04/2008 = le 121ème jour de l'année 2008) |
datenumjouran(n,a) => donne la date qui est le nième jour de l'année "a".
|
datenumjouran(315,2007) => "11/11/2007" |
postdate(D1,D2) => dit si une date D2 'j/m/a' est postérieure ou égale à une autre date D1 'j/m/a'
|
postdate("31/12/2008","1/1/2009") => True |
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.
|
diffdate("14/7/1789","11/11/2007") => 79742 diffdate("1/1/2008","11/11/2007") => -51 |
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.
|
adddate("11/11/2007",-79742) => "14/07/1789" adddate("11/11/2007",51) => "01/01/2008" |
numjoursem(D) => donne le numéro du jour de la semaine d'une date D 'j/m/a' (lundi=1, ...).
|
numjoursem("1/1/2008") => 2 (donc, c'est un mardi) |
joursem(D) => donne le jour de la semaine d'une date D 'j/m/a' ('lundi' pour lundi, ...).
|
joursem("1/1/2008") => "mardi" (je vous l'avais bien dit) |
lundi(D) => trouve la date du lundi d'une semaine qui contient une date D 'j/m/a'.
|
lundi("1/1/2008") => "31/12/2007" |
debmoissuivant(D) = donne la date '01/mm/aaaa' au 1er du mois qui suit D 'j/m/a'
|
debmoissuivant("15/7/2008") => "1/8/2008" |
estweekend(D) => dit si une date D donnée 'j/m/a' correspond à un samedi ou un dimanche
|
estweekend("1/1/2008") => False (c'était un mardi) estweekend(paques(2008)) => True |
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 .
|
paques(2008) => "23/03/2008" |
ascension(an) => trouve la date du jeudi de l'ascension (paques + 39j).
|
ascension(2008) => "01/05/2008" |
pentecote(an) => trouve la date du dimanche de la pentecote (paques + 49j).
|
pentecote(2008) => "11/05/2008" |
feries(an,sd=1) => renvoie la liste des jours fériés (France) de l'année donnée en 1er paramètre.
=> à adapter selon votre situation, region, pays, besoins et évolution de la législation
|
feries(2008) affiche (sur une ligne): ["Jour de l'an = mardi 01/01/2008","Jour de Pâques = dimanche 23/03/2008","lundi de Pâques= lundi 24/03/2008","Fête du Travail = jeudi 01/05/2008","Fête de la Victoire 1945 = jeudi 08/05/2008","Ascension = jeudi 01/05/2008","Pentecôte = dimanche 11/05/2008","Lundi de Pentecôte = lundi 12/05/2008","Fête Nationale = lundi 14/07/2008","Assomption = vendredi 15/08/2008","Toussaint = samedi 01/11/2008","Armistice 1918 = mardi 11/11/2008","Noël = jeudi 25/12/2008"] |
estferie(D,sd=1) => dit si une date D donnée 'j/m/a' est fériée France. Avec sd>1, on a en plus les 2 jours fériés supplémentaires d'Alsace-Moselle (le vendredi saint et le lendemain de Noël). Attention: un dimanche normal n'est pas un "jour férié", mais le dimanche de Pâques, si.
|
estferie(ascension(2008)) => True estferie(paques(2008)) => True |
diffdateouvre(D1,D2,sd=1) = calcule le nombre de jours ouvrés entre 2 dates, c'est à dire ici sans samedi, ni dimanche ni jour férié. Si sd>1: calcul pour l'Alsace-Moselle (+ vendredi saint et le lendemain de Noël). Attention, il s'agit bien d'une différence: le dernier jour n'est pas compté.
|
diffdateouvre("1/1/2008","1/1/2009") => 253 jours ouvrés (=ni weekend, ni jour férié) diffdateouvre("28/4/2008","4/5/2008") => 4 jours (il y a le 1er mai entre les 2 dates) |
phaseslune(D,n) = calcul des n dates de phase de la lune qui commence(nt) à la date D 'j/m/a'
Exemple: calcul des 4 dates de phase de la lune qui suivent le 1er janvier 2009:
|
phaseslune('1/1/2009',4) => [["04/01/2009","premier quartier"],["11/01/2009","pleine lune"],["18/01/2009","dernier quartier"],["26/01/2009","nouvelle lune"]] |
phaseslune2(D1,D2) = calcul des dates de phase de la lune à partir de D1 'j/m/a' et jusqu'à D2 'j/m/a' exclue
Exemple: toutes les phases de la lune du mois de décembre 2008:
|
phaseslune2('1/12/2008','1/1/2009') => [["05/12/2008","premier quartier"],["12/12/2008","pleine lune"],["19/12/2008","dernier quartier"],["27/12/2008","nouvelle lune"]] |