Proglab - Doc - Équivalences : affectations et calculs

Équivalences entre différents langages : entrées, sorties et calculs

Avec la participation de mathazay.

Partie 1 : variables, commentaires, structure du programme
Partie 2 : affectations, entrées/sorties, calculs

Affectation
Entrées
Sorties
Arithmétique
Fonctions diverses
Trigonométrie
Loi binomiale
Loi normale
Références

Partie 3 : tests, conditions et boucles

Affectation

L'affectation est le fait de stocker une valeur dans une variable.

Au bac	« Affecter à n la valeur 5,1 » « n prend la valeur 5,1 »¹
Algobox	`n PREND_LA_VALEUR 5.1`
Javascript	`n = 5.1;`
Python	`n = 5.1`

R	`n <- 5.1` ou `5.1 -> n`
Casio	`5.1→N`
TI-Basic	`:5.1→N`
Xcas	`n:=5.1`
XLogo	`donne "n 5.1`

¹ on peut trouver des notations spécifiques, comme n := 0 (sujet de Pondichéry 2012) mais elles sont expliquées en début d'exercice.

Entrées : demander une valeur à l'utilisateur

Au bac	« Saisir le nombre n » « Demander à l'utilisateur la valeur de n »
Algobox	`LIRE n`
Javascript	Pour entrer une chaîne de caractères : `s = prompt("Entrez s");` Pour entrer un nombre : `n = parseFloat(prompt("Entrez n"));`
Python	Pour entrer une chaîne de caractères : `s = input("Entrez s")` Pour entrer un nombre : `n = float(input("Entrez n"))`
R	Pour entrer une chaîne de caractères¹ : `s <- readline(prompt = "Entrez s : ")` Pour entrer un nombre : `n <- as.numeric(readline(prompt = "Entrez n : "))`

Casio	Sans message : `?→N` Avec message : `"ENTREZ N"?→N`
TI-Basic	Sans message : `:Input N` Avec message : `:"ENTREZ N", Input N` ou `:Prompt N`
Xcas	`saisir("Entrez n",n)`
XLogo	`lis [Entrez s] "s`

¹ variantes :
s <- readline("Entrez s : ") (prompt = peut être omis)
s <- readline("Entrez s :\n") (Le caractère \n (newline) provoque un retour à la ligne : l'entrée de s se fait sur une nouvelle ligne)

Sorties : afficher des résultats

L'affichage des résultats varie d'un langage à l'autre, et même d'une version à l'autre du même langage comme en Python.
Commençons par le plus simple, l'affichage d'une valeur sans rien d'autre :

Au bac	Afficher la valeur de n
Algobox	Sans retour à la ligne : `AFFICHER n` Avec retour à la ligne : `AFFICHER* n`
Javascript	Afficher dans une fenêtre pop-up : `alert(n);` Dans une page web, afficher à la suite du document : `document.write(n);`¹ Avec retour à la ligne : `document.writeln(n);`¹
Python 2	Avec retour à la ligne : `print n` Sans retour à la ligne : `print n,`

Python 3	Avec retour à la ligne : `print(n)` Sans retour à la ligne : `print(n, end='')`
R	`print(n)`
Casio	`N◢`
TI-Basic	`:Disp N`
Xcas	`afficher(n)`
XLogo	`ecris :n`

Notes :
¹ document.write n'est pas une méthode habituelle pour faire des affichages en JavaScript. Les méthodes recommandées sont nombreuses et impliquent de désigner des éléments de la page. Ceci dépasse largement le cadre de l'algorithmique au lycée, et pour simplifier les choses, les méthodes recommandées pour écrire dans le document en cours sur proglab.fr sont document.write et document.writeln.

Dans la pratique on a souvent besoin d'améliorer un peu cet affichage, ne serait-ce que pour indiquer quelle valeur on affiche :

Algobox	AFFICHER "n vaut " AFFICHER n ou AFFICHERCALCUL "n vaut " + n
Javascript	Afficher dans une fenêtre pop-up : `alert("n vaut " + n);` Dans une page web, afficher à la suite du document : `document.write("n vaut " + n);`
Python 2	Avec retour à la ligne : `print "n vaut", n` Sans retour à la ligne : `print "n vaut", n,`
Python 3	Avec retour à la ligne : `print("n vaut", n)` Sans retour à la ligne : `print("n vaut", n, end='')`

R	Sans retour à la ligne : `cat("n vaut ", n)` Avec retour à la ligne : `cat("n vaut ", n, "\n")`
Casio	`"N VAUT":N◢`
TI-Basic	`:Disp "N VAUT", N`
Xcas	`afficher("n vaut",n)`
XLogo	`ecris phrase [n vaut : ] :n`

Arithmétique

Dans un algorithme sur papier, on écrit les calculs comme d'habitude en math, mais dans les langages de programmation les calculs doivent être écrits sur une seule ligne, avec en plus quelques différences pour les fonctions mathématiques de base.
Python nécessite d'importer explicitement le module math (import math) pour l'utilisation des fonctions préfixées par math., le module random pour générer des nombres aléatoires, et le module scipy.stats pour les lois de proba (from scipy import stats après avoir installé scipy)
Pour les fonctions trigonométriques les angles sont en radians, à part pour les calculatrices qui acceptent aussi les degrés.

Calcul	a+b	a−b	a×b	a÷b	division entière (quotient) de a par b	reste de la division entière (modulo) de a par b	a^b
Algobox	`a+b`	`a-b`	`a*b`	`a/b`	`floor(a/b)`	`a%b`	`pow(a, b)`
Javascript	`a+b`	`a-b`	`a*b`	`a/b`	`Math.floor(a/b)`	`a%b`	`Math.pow(a, b)`
Python	`a+b`	`a-b`	`a*b`	Python 2 : Si a et b sont des décimaux : `a/b` Si a et b sont des entiers : `float(a)/b` Ou avec des valeurs : `3./2.` Python 3 : `a/b`	`a//b`	`a%b`²	`a**b` ou `pow(a, b)`
R	`a+b`	`a-b`	`a*b`	`a/b`	`a%/%b`	`a%%b`²	`a^b`
Casio	`A+B`	`A−B`	`AB` ou `A×B`	`A÷B`	`Intg (A÷B)`¹	`Frac (A÷B)×B`³	`A^B`
TI-Basic	`A+B`	`A−B`	`AB` ou `A*B`	`A/B`	`int (A/B)`¹	`fPart (A/B)*B`³	`A^B`
Xcas	`a+b`	`a-b`	`a*b`	`a/b`	`iquo(a,b)`	`irem(a,b)`²	`a^b`
XLogo	`a+b`	`a-b`	`a*b`	`a/b`	`quotient a b`	`reste a b`²	`puissance a b`

Notes :
¹ Ces instructions donnent −3 pour le quotient de −17 par 7, comme toutes les autres de la même colonne du tableau.
Les instructions Int (A÷B) (Casio) et iPart (A/B) (TI) donneraient −2.
² Python et R ont ici un comportement original pour les nombres négatifs : pour −17 modulo 7, ils donnent 4 là où les autres donnent −3. C'est plus cohérent avec le quotient de la division euclidienne. Python propose aussi la fonction math.fmod(a, b) qui donne −3 comme les autres.
³ Frac (Casio) et fPart (TI) donnent la partie fractionnaire de la division, ces calculatrices n'ont pas d'opérateur modulo (sauf peut-être des modèles récents ?)

Fonctions diverses

Calcul	√a	√x²+y² ⁽⁴⁾	ln(x)⁵	e^x	e	sgn(x) (signe de x : −1, 0 ou 1 selon que x est négatif, nul ou positif)	\|x\|
Algobox	`sqrt(a)`		`log(x)`	`exp(x)`	`Math.E`		`abs(x)`
Javascript	`Math.sqrt(a)`		`Math.log(x)`	`Math.exp(x)`	`Math.E`		`Math.abs(x)`
Python	`math.sqrt(a)`	`math.hypot(x, y)`	`math.log(x)`	`math.exp(x)`⁶	`math.e`		`abs(x)`
R	`sqrt(a)`		`log(x)`	`exp(x)`	`exp(1)`	`sign(x)`	`abs(x)`
Casio	`√A`		`ln X`	`e^X`	`e^1`		`Abs X`
TI-Basic	`√(A)`		`ln(X)`	`e^(X)`	`e^(1)`		`abs(X)`
Xcas	`sqrt(a)`		`log(x)`	`exp(x)` ou `e^x`	`e`	`sign(x)`	`abs(x)`
XLogo	`racine a` ou `rac a`		`log x`	`exp x`	`exp 1`		`abs x`

Notes :
⁴ Plusieurs langages, dont Python, ont cette fonction spéciale pour éviter les problèmes de dépassement de capacité lors du calcul de la somme des carrés.
⁵ Certains langages ont une fonction spéciale pour le logarithme à base 10 : log10(x) en Python et Xcas, log10 x en XLogo.
Python et R possèdent en outre les fonctions log2(x) pour le logarithme à base 2 (pour Python, à partir de la version 3.3), et log1p(x) pour calculer ln(1+x) sans perte de précision pour les valeurs de x proches de 0.
⁶ Python possède aussi la fonction expm1(x) pour calculer e^x−1 sans perte de précision pour les valeurs de x proches de 0.

Calcul	arrondi supérieur ⌈x⌉	arrondi inférieur ⌊x⌋	arrondi à l'entier le plus proche	troncature	nombre pseudo-aléatoire entre 0 et 1 avec une distribution uniforme⁷	minimum	maximum
Algobox	`Math.ceil(x)`	`floor(x)`	`round(x)`		`random()`	`min(a, b)`	`max(a, b)`
Javascript	`Math.ceil(x)`	`Math.floor(x)`	`Math.round(x)`		`Math.random()`	`Math.min(a, b)`	`Math.max(a, b)`
Python	`math.ceil(x)`	`math.floor(x)`	`round(x)`	`trunc(x)`	`random.random()`	`min(a, b)`	`max(a, b)`
R	`ceiling(x)`	`floor(x)`	`round(x)`	`trunc(x)`	`runif(1)`	`min(a, b)`	`max(a, b)`
Casio		`Intg X`		`Int X`	`Ran#`
TI-Basic		`int(X)`	`round(X,0)`	`iPart(X,0)`	`rand`	`min(A,B)`	`max(A,B)`
Xcas	`ceil(x)`	`floor(x)`	`round(x)` ou `round(x,n)`	`trunc(x)` ou `trunc(x,n)`	`alea(0,1)`	`min(a,b)`	`max(a,b)`
XLogo			`arrondi x`	`tronque x`	`alea`

Notes :
⁷ Python en tant que langage scientifique, et surtout R en tant que langage spécialisé en statistiques et probabilités, possèdent beaucoup de fonctions pour générer des nombres aléatoires suivant diverses contraintes (entiers, réels) et de nombreuses distributions de probabilités.

Trigonométrie

Calcul	sin(x)	cos(x)	tan(x)	sin⁻¹(x)	cos⁻¹(x)	tan⁻¹(x)	arg(x+iy)⁸	π
Algobox	`sin(x)`	`cos(x)`	`tan(x)`	`asin(x)`	`acos(x)`	`atan(x)`	`Math.atan2(y, x)`	`Math.PI`
Javascript	`Math.sin(x)`	`Math.cos(x)`	`Math.tan(x)`	`Math.asin(x)`	`Math.acos(x)`	`Math.atan(x)`	`Math.atan2(y, x)`	`Math.PI`
Python	`math.sin(x)`	`math.cos(x)`	`math.tan(x)`	`math.asin(x)`	`math.acos(x)`	`math.atan(x)`	`math.atan2(y, x)`	`math.pi`
R	`sin(x)`	`cos(x)`	`tan(x)`	`asin(x)`	`acos(x)`	`atan(x)`	`atan2(y, x)`	`pi`
Casio	`sin X`	`cos X`	`tan X`	`sin^-1 X`	`cos^-1 X`	`tan^-1 X`		`π`
TI-Basic	`sin(X)`	`cos(X)`	`tan(X)`	`sin^-1(X)`	`cos^-1(X)`	`tan^-1(X)`		`π`
Xcas	`sin(x)`	`cos(x)`	`tan(x)`	`asin(x)`	`acos(x)`	`atan(x)`	`atan2(x, y)`	`pi`
XLogo	`sin x`	`cos x`	`tan x`	`asin x`	`acos x`	`atan x`		`pi`

Notes :
⁸ la différence entre cette fonction et atan(y/x) est que, connaissant le signe de x et de y, elle peut calculer le bon angle et le bon quadrant. Elle renvoie un résultat entre −π et π, alors que atan renvoie des résultats entre −π/2 et π/2.
Pour l'utiliser dans Algobox, le préfixe Math. est nécessaire.

Loi binomiale

Calcul	Coefficient binomial (n k)	Loi binomiale(n, p) P(X = k)	Loi binomiale(n, p) P(X ≤ k)	Loi binomiale(n, p) k tel que P(X ≤ k) = q⁹
Algobox	`ALGOBOX_COEFF_BINOMIAL(n,k)` `ALGOBOX_NB_COMBINAISONS(n,k)`	`ALGOBOX_LOI_BINOMIALE(n,p,k)`
Javascript (sur proglab uniquement¹⁰)	`ALGOBOX_COEFF_BINOMIAL(n,k)` `ALGOBOX_NB_COMBINAISONS(n,k)`	`ALGOBOX_LOI_BINOMIALE(n,p,k)`
Python	`special.binom(n, k)`¹¹	`stats.binom.pmf(k, n, p)`	`stats.binom.cdf(k, n, p)`	`stats.binom.ppf(q, n, p)`
R	`choose(n, k)`	`dbinom(k, n, p)`	`pbinom(k, n, p)`	`qbinom(q, n, p)`
Casio	`n nCr k`	`BinomialPD(k,n,p)`	`BinomialCD(k,n,p)`	`InvBinomialCD(q,n,p)`
TI-Basic	`n nCr k`	`binompdf(n,p,k)`¹²	`binomcdf(n,p,k)`¹²
TI-Basic-fr	`n Combinaison k`	`binomFdp(n,p,k)`¹²	`binomFRép(n,p,k)`¹²
Xcas	`binomial(n,k)`	`binomial(n,k,p)`	`binomial_cdf(n,p,k)`	`binomial_icdf(n,p,q)`
XLogo	Pas de fonctions pour les probabilités.

Notes :
⁹ En fait, le plus petit entier k tel que P(X ≤ k) ≥ q
¹⁰ De base, JavaScript n'a aucune fonction pour les probabilités. Des fonctions spéciales ont été ajoutées sur Proglab. Toutes les fonctions d'Algobox sont aussi utilisables.
¹¹ Nécessite d'importer scipy.special (from scipy import special si le module scipy est installé)
¹² Le paramètre k est optionnel. Si on ne le précise pas, ces fonctions donnent la liste complète des probas pour toutes les valeurs de k.

Loi normale

Calcul	Loi normale(μ, σ²) (resp. loi normale(0, 1) ) P(X ≤ b)	Loi normale(μ, σ²) (resp. loi normale(0, 1) ) P(a ≤ X ≤ b)	Loi normale(μ, σ²) (resp. loi normale(0, 1) ) b tel que P(X ≤ b) = q
Algobox	`ALGOBOX_LOI_NORMALE(μ,σ,b)` `ALGOBOX_LOI_NORMALE_CR(b)`	Calculer P(X ≤ b) − P(X ≤ a)	`ALGOBOX_INVERSE_LOI_NORMALE(μ,σ,q)` `ALGOBOX_INVERSE_LOI_NORMALE_CR(q)`
Javascript (sur proglab uniquement¹⁰)	`ALGOBOX_LOI_NORMALE(μ,σ,b)` `ALGOBOX_LOI_NORMALE_CR(b)`	Calculer P(X ≤ b) − P(X ≤ a)	`ALGOBOX_INVERSE_LOI_NORMALE(μ,σ,q)` `ALGOBOX_INVERSE_LOI_NORMALE_CR(q)`
Python	`stats.norm.cdf(b, μ, σ)` `stats.norm.cdf(b)`	Calculer P(X ≤ b) − P(X ≤ a)	`stats.norm.ppf(q, μ, σ)` `stats.norm.ppf(q)`
R	`pnorm(b, μ, σ)` `pnorm(b)`	Calculer P(X ≤ b) − P(X ≤ a)	`qnorm(q, μ, σ)` `qnorm(q)`
Casio	`NormCD(-100,b,σ,μ)` `NormCD(-100,b)`¹³	`NormCD(a,b,σ,μ)` `NormCD(a,b)`	`InvNormCD(q,σ,μ)` `InvNormCD(q)`
TI-Basic	`normalcdf(-100,b,μ,σ)` `normalcdf(-100,b)`¹³	`normalcdf(a,b,μ,σ)` `normalcdf(a,b)`	`InvNorm(q,μ,σ)` `InvNorm(q)`
TI-Basic-fr	`normalFRép(-100,b,μ,σ)` `normalFRép(-100,b)`¹³	`normalFRép(a,b,μ,σ)` `normalFRép(a,b)`	`FracNormale(q,μ,σ)` `FracNormale(q)`
Xcas	`normald_cdf(μ,σ,b)`	`normald_cdf(μ,σ,a,b)`	`normald_icdf(μ,σ,q)`
XLogo	Pas de fonctions pour les probabilités.

Notes :
¹³ Sur les Casio et TI, il n'y a pas de fonction spéciale pour P(X ≤ b), donc on calcule P(a ≤ X ≤ b) avec une borne a suffisamment basse (dans l'idéal ce serait −∞). Pour une loi normale centrée réduite, −10 ou −100 conviennent parfaitement : en effet P(X ≤ 10) < 10⁻²³. Si la loi n'est pas centrée réduite, il faudra peut-être utiliser des valeurs plus basses.

Références

Algobox : manuel officiel
Javascript : Référence Javascript en français sur le Mozilla Developer Network.
Python : Python sur wikipedia
R :
Aide-mémoire R
Support de cours sur le logiciel R (Master Statistiques Appliquées, université de Rennes 2)
R short refcard (anglais)
Xcas :
Aide-mémoire XCas au lycée
Site officiel (Bernard Parisse, Institut Fourier, université de Grenoble I)
Algorithmique et traduction pour Xcas (Renée De Graeve)
XLogo : Site officiel

Calculatrices :
Le Basic des calculatrices graphiques Texas Instruments sur wikipédia
mode d'emploi de la TI-82 stats.fr (voir le chapitre 16 : programmation)
Programmes sous TI sur le site de l'académie de Rouen
mode d'emploi des calculatrices Casio (la programmation est au chapitre 8)
Programmes sous CASIO sur le site de l'académie de Rouen

Ce texte est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 3.0 non transposé.
Dernière modification le 24 nov 2013

commentaires avec Disqus