Alcoffeethmique

mardi 17 septembre 2013
par  Alain BUSSER , Florian TOBÉ

Pour programmer avec alcoffeethmique en ligne, on peut soit utiliser cette page, soit aller sur la version la plus récente

Et voici en bonus, un petit utilitaire sur les fonctions

Voici une version utilisable hors ligne (en « local ») avec tous les utilitaires nécessaires :

Zip - 353.2 ko
Alcoffeethmique
utilitaires de programmation Coffee

L’usage du clavier est minimal :

  • Si on touche (ou clique sur) un exemple dans l’aide, il s’insère à la fin du script avec saut à la ligne
  • Si on touche (ou clique sur) un exemple, il remplace le contenu actuel du script, et peut alors être exécuté en cliquant sur le bouton « cours »
  • Les chiffres et symboles opératoires peuvent être sélectionnés dans un menu déroulant
  • les instructions peuvent être insérées par clic après choix dans le menu
  • l’indentation courante est réglée par un curseur.
interpréteur CoffeeScript

Algorithmique avec CoffeeScript

niveau d'indentation 0

Sorties graphiques

Le tableau

Le graphique

Le fichier du graphique au format svg

On peut

  1. Modifier le contenu à l'aide du clavier (typiquement, changer la valeur de x pour un texte)
  2. Sélectionner le tout (Ctrl+A ou pomme+A ou appui long)
  3. Copier le svg (Ctrl+C ou pomme+C)
  4. Coller le contenu dans un éditeur de texte
  5. Sauvegarder dans un fichier ayant l'extension .svg
  6. Ce fichier peut alors être
    • être ouvert par Inkscape, puis exporté en pdf ou ps (pour import dans LaTeX)
    • être inséré dans un fichier odt sous Libre Office
    • être importé dans wikipedia
    • etc

aide

Affectation, entrée et sortie de données

Affectation

En Coffeescript, l'affectation est notée par un "=".

Par exemple,

  1. Pour mettre 2 dans x:
    x = 2
  2. Pour le remplacer par 3:
    x = x+1

Une variable peut être affectée par un nombre mais aussi par du texte, une liste ou même une fonction.

Affectation simultanée

On peut affecter simultanément a par 1 et b par 2 avec

[a,b] = [1,2]

Raccourcis

Pour augmenter x de 1, on peut faire indifféremment

x = x+1
x += 1
x++

Entrée de données

Pour faire entrer un nombre x par l'utilisateur, il faut affecter x (donc écrire un signe "égal") et afficher un message d'invite rappelant ce que représente le nombre. Par exemple

x = entre "Quelle valeur donner à x ?"

Affichage de données

Tant qu'on ne demande pas à CoffeeScript d'afficher le résultat d'un calcul, on ne peut pas connaître celui-ci. Il y a deux moyens de faire connaître le contenu de x:

  • créer une boîte modale d'affichage contenant x avec
    alerte x
  • afficher x dans le cadre prévu à cet effet à droite de la page avec
    affiche x

Fractions

création d'une fraction

Pour créer une fracction, il faut lui attribuer un numérateur et un dénominateur. Par exemple, pour créer la fraction "2 tiers", on entre

nouvelle Fraction 2, 3
L'affectation de fractions est pratique pour effectuer des calculs.

Affichage

Pour afficher une fraction, on met le mot "affiche" devant son nom:

a = nouvelle Fraction 2, 3
affiche a
On peut aussi afficher une valeur approchée de la fraction avec "toFloat()":
a = nouvelle Fraction 2, 3
affiche a.toFloat()

Opérations

Addition

Pour additionner deux fractions, on met ".plus" entre les deux:

a = nouvelle Fraction 2, 3
b = nouvelle Fraction 3, 4
affiche a.plus b

Soustraction

Pour soustraire deux fractions, on met ".moins" entre les deux:

a = nouvelle Fraction 2, 3
b = nouvelle Fraction 3, 4
affiche a.moins b

Multiplication

Pour multiplier deux fractions, on met ".fois" entre les deux:

a = nouvelle Fraction 2, 3
b = nouvelle Fraction 3, 4
affiche a.fois b

Division

Pour diviser deux fractions, on met ".sur" entre les deux:

a = nouvelle Fraction 2, 3
b = nouvelle Fraction 3, 4
affiche a.sur b

Fonctions

Opposé

On peut calculer l'opposé d'une fraction (qu'elle soit négative ou positive):

a = nouvelle Fraction 2, -3
affiche a
affiche a.opposé()

Inverse

En général, l'inverse d'une fraction n'est pas égal à son opposé:

a = nouvelle Fraction 2, -3
affiche a
affiche a.inverse()

Fractions égyptiennes

Pour connaître la décomposition d'une fraction supérieure à 1 sous la forme d'une somme comportant

  • Un entier
  • des fractions "égyptiennes" (de numérateur 1)
on fait
a = nouvelle Fraction 355, 113
affiche egypt a
ce qui apprend par exemple que 355/113 = 3+1/8+1/61+1/5014+1/27649202+1/1911195900442808.

Simulation du hasard

Pour lancer un dé à 6 faces

affiche dé 6

Le nombre de faces doit être en entier, sans limite.

Pour vérifier, on peut lancer 10 fois le dé:

(dé 6 pour n dans [1..10])

Pile ou face

Pour jouer à pile ou face, on lance un dé à deux faces.

Loi uniforme sur [0;1[

affiche alea()

donne un nombre aléatoire entre 0 et 1

Application

On peut alors simuler une variable aléatoire Z normale centrée (d'espérance 0) et réduite (d'écart-type 1) avec

Z = -6
pour n dans [0...12]
    Z += alea()
affiche Z

Essayer par exemple

gauss = () ->
    Z = -6
    Z += alea() pour n dans [0...12]
    Z

grosTableau = (gauss() pour n dans [1..1000])

histogramme grosTableau, -3, 3, 15, 200
-3-2,6-2,2-1,8-1,4-1-0,6-0,20,20,611,41,82,22,63

Logique

Égalité

Pour tester l'égalité entre deux objets, il y a deux manières:

  • avec un double égal comme dans 2+2 == 4
  • avec le verbe is ("est") comme dans 2+2 is 4

affiche 2+2 est égal à 5

affiche false (ben oui!)

Négation

Pour obtenir le contraire d'une proposition, la précéder par un point d'exclamation

affiche not 2+2==5
affiche 2+2 est différent de 5

Le symbole "≠" se note donc isnt ou != ou "est différent de", au choix.

Conjonction

Pour dire que x est à la fois positif et pair, on peut écrire

x>0 et x%2 est égal à 0

Disjonction

Pour dire que x est, ou bien positif, ou bien pair (ou les deux), on peut écrire

x > 0 ou x%2 est égal à 0

Une alternative est le double trait vertical.

Pour taper le symbole "trait vertical", appuyer avec la main droite sur et, sans lâcher ce bouton, actionner le en haut du clavier, de la main gauche.

Booléens

Tests

Test simple

Un test est une instruction conditionnelle; Pour n'effectuer quelque chose que lorsqu'une condition est vraie (par exemple seulement si le dé est tombé sur 6), faire

si dé(6) est égal à 6
    affiche "gagné"

On remarque l'indentation qui précise que la partie affiche "gagné" ne doit s'effectuer que si le dé vaut 6.

affiche "gagné" si dé(6) est égal à 6

a le même effet.

Test multiple

Que faire quand le dé ne tombe pas sur 6 ?

Si on ne s'intéresse pas au gain mais seulement à la défaite, on est pessimiste et on écrit

affiche "perdu" à moins que dé(6) == 6

Mais les deux cas peuvent être traités ensemble:

si dé(6) est égal à 6
    affiche "gagné"
sinon
    affiche "perdu"

Intervalles

On peut aussi faire un test dans un intervalle:

(x pour x dans [1..12] quand x%2==0)

Intervalles

En CoffeeScript, les intervalles sont composés uniquement d'entiers. L'intervalle fermé [a;b] se note [a..b] avec deux points; L'intervalle ouvert à droite [a;b[ se note [a...b] avec trois points; L'appartenance se note in; Pour vérifier que 2 est compris entre 0 et 5:

affiche 2 dans [0..5]
affiche 0 <= 2 <= 5
	

L'appartenance est aussi utilisée pour appliquer une fonction à un intervalle:

affiche (x*x pour x dans [0..5])

Ensembles

Ajout d'un élément

Pour ajouter un élement x à un ensemble A:

A.empile x

Retrait d'un élément

Pour enlever le nombre 5 d'un ensemble A:

A = (x pour x dans A quand x est différent de 5)

Intervalles d'entiers

Ensembles

Intersection

L'intersection de deux ensembles A et B est formée des x de A qui sont aussi dans B:

I = (x pour x dans A quand x dans B)

Complémentaire

Une légère différence mais qui change tout:

(x for x in A when x not in B)

est le complémentaire de B dans A.

En probabilités, cette notion formalise le contraire d'un évènement.

Réunion

La réunion de deux intervalles n'est pas nécessairement un intervalle:

A = (x pour x dans [0..100] quand 2 < x < 15 ou 80 <= x < 90)
affiche A

Multiensembles

À la différence d'un ensemble, un multiensemble (ou sac) peut contenir plusieurs occurences d'un élément. On crée un sac à partir d'un tableau, on ajoute un élément dans un sac comme dans un ensemble, mais on peut aussi ajouter plusieurs fois un élement d'un coup. Ainsi, pour créer une urne contenant 7 boules rouges et 3 boules bleues, on peut faire, ou bien

urne = nouveau Sac ['rouge','rouge','rouge','rouge','rouge','rouge','rouge','bleu','bleu','bleu']

ou bien

urne = nouveau Sac []
urne.ajoute 'rouge' pour n dans [1..7]
urne.ajoute 'bleu' pour n dans [1..3]

ou enfin

urne = nouveau Sac []
urne.ajouteFois 7, 'rouge'
urne.ajouteFois 3, 'bleu'

On peut calculer les intersection et réunion de deux multiensembles comme pour les ensembles, oter un élément d'un multiensemble avec .ote élément ou extraire un élément au hasard d'un multiensemble; comme pour un ensemble, le cardinal d'un multiensemble est le nombre d'éléments (comptés avec leur multiplicité) qu'il contient. sac.contient x teste si l'élément x se trouve ou non dans le sac.

l'Infini dans CoffeeScript

Si on divise 0 par 0 on obtient NaN (not a number) qui signifie que la division n'a pas de sens. Mais si on divise 1 (ou tout autre nombre non nul) par 0, on obtient Infinity, ce qui veut dire que lorsqu'une variable x tend vers 0, son inverse 1/x tend vers l'infini;

De même,

1/Infinity

donne 0: Si une variable x tend vers l'infini, son inverse 1/x tend vers 0.

Opérations

Addition

affiche Infinity+Infinity

La somme de deux fonctions qui tendent vers +∞ tend elle-même vers +∞

affiche 3+Infinity

La somme d'une fonction qui tend vers 3 et d'une fonction qui tend vers +∞ tend elle-même vers +∞

affiche Infinity-Infinity

On ne peut rien conclure sur la somme d'une fonction qui tend vers +∞ et d'une fonction qui tend vers -∞: Il s'agit d'une forme indéterminée.

Multiplication

affiche Infinity*Infinity

Le produit de deux fonctions qui tendent vers +∞ tend lui-même vers +∞

affiche 3*Infinity

Le produit d'une fonction qui tend vers 3 et d'une fonction qui tend vers +∞ tend lui-même vers +∞

affiche 0*Infinity

On ne peut pas conclure sur le produit d'une fonction qui tend vers ∞ et d'une fonction qui tend vers 0: Il s'agit d'une forme indéterminée.

Croissance comparée

affiche leLogarithmeDe 0
affiche leLogarithmeDe Infinity

La limte de ln en 0 est -∞ et la limite de ln en +∞ est +∞

affiche exp -Infinity
affiche exp Infinity

La limite de ex est 0 lorsque x tend vers -∞ et +∞ lorsque x tend vers +∞.

Fonctions

Une fonction associe à une variable d'entrée (ou plusieurs) appelée antécédent, une (ou plusieurs) variable de sortie appelée image; l'image de x par la fonction f est notée f(x); Aussi, en CoffeeScript, une fonction est-elle désignée par une flèche -> séparant l'antécédent, entre parenthèses, de l'image, qui est une expression. Après la flèche on peut insérer un algorithme destiné à calculer la fonction par algorithme.

La dernière ligne écrite dans la fonction est la valeur retournée.

Une fonction peut ne pas avoir d'antécédent, dans ce cas c'est une procédure.

Cas particuliers

Fonctions constantes

(x) -> 3

est une fonction constante.

Fonctions affines
(x) -> x/2+1

est une fonction affine.

Une variable peut être une fonction

On peut affecter une variable par une fonction comme dans

f = (x) ->
    x*x-2*x-1

Ensuite on peut entrer f(3) ou f 3 pour avoir l'image de 3 par f.

Fonctions prédéfinies

Parmi les fonctions prédéfinies, on trouve

  • sinus et cosinus en degrés (pour l es radians, utiliser sin et cos)
  • laRacineDe pour la racine carrée; leCarréDe, leCubeDe pour le carré et le cube d'un nombre; lInverseDe pour l'inverse d'un nombre (1 divisé par ce nombre)
  • leLogarithmeDe pour le logarithme népérien, et lExponentielleDe pour ex.
  • les fonctions de JavaScript sont disponibles dans CoffeeScript

Tableau de valeurs

Pour avoir un tableau de valeurs d'une fonction, on peut construire un tableau associatif dans lequel on associe à chaque valeur de x choisie, son image par la fonction. Ensuite on peut afficher ce tableau associatif dans le tableau ci-dessus ("sorties graphiques")

tableauAssoc = {}
pour x dans [1,2,3,5,10]
    tableauAssoc[x] = leCarréDe x
trierDansTableau tableauAssoc
    

Plus court: On peut afficher les x et leurs images dans l'affichage:

pour x dans [1,2,3,5,10]
    affiche "#{x},   #{leCarréDe x}"
    

Ensuite, on sélectionne à la souris les nombres, et on les copie-colle dans un fichier portant l'extension "csv" (par exemple carré.csv); il suffit ensuite d'ouvrir ce fichier avec un tableur pour avoir non seulement le tableau, mais aussi la représentation graphique.

Boucles

Boucler n fois

Pas à pas

Pour répéter 10 fois une action, on a besoin d'une variable appelée indice de la boucle. Ici on notera i cet indice, qui ira de 1 à 10.

Par exemple, pour lancer un dé 10 fois, on peut entrer

pour i dans [1..10]
    affiche dé 6

Un bon moyen de suivre l'indice d'une boucle est d'afficher celui-ci dans la boucle:

pour i dans [1..10]
    affiche i
Remarque:
affiche i pour i dans [1..10]

a le même effet: Afficher i pour i entre 1 et 10. Alors que si on ajoute des parenthèses, il n'y a plus qu'un affichage, les parenthèses produisant une liste:

affiche (i pour i dans [1..10])

Les nombres 1, 2, 3 etc parcourus forment une suite arithmétique de raison 1.

Autres suites arithmétiques

Pour faire descendre l'indice (compte à rebours) on peut faire

affiche i pour i dans [10..1]

Pour aller de 3 en 3 on peut faire

affiche i pour i dans [1..10] quand i%3 est 1

ou, mieux:

affiche i pour i dans [1..10] par pas de 3

Boucler sur les nombres premiers

Pour boucler sur les nombres premiers inférieurs à 20:

pour i dans [2,3,5,7,11,13]

Boucler jusqu'à une condition

Pour lancer un dé jusqu'à ce qu'on ait un 6 (et compter les lancers dans un indice i), on fait

Jusque

i=0
i++ jusqu'à ce que dé(6) == 6

Il y a plusieurs manières de faire ça; par exemple

i=1
i++ jusqu'à ce que dé(6) == 6

Tant que

On peut aussi faire comme ceci:

i=1
tant que dé(6) est différent de 6
    i=i+1

Dé icosaédrique

Un dé icosaédrique, comme son nom l'indique, a 20 faces numérotées de 1 à 20. L'univers de probabilité est alors Ω={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}; On peut le calculer en fabricant un ensemble à partir de la liste des nombres allant de 1 à 20 :

univers = nouvel Ensemble [1..20]

affiche univers
	

Évènements

L'évènement «le résultat est pair» s'écrit A={2,4,6,8,10,12,14,16,18,20}; il peut se définir en compréhension par

A = nouvel Ensemble (x pour x dans univers.support quand x%2 == 0)
	

L'évènement «le résultat s'écrit avec un seul chiffre» peut se définir de façon analogue mais aussi en faisant comme pour l'univers; on obtient B={1,2,3,4,5,6,7,8,9}

B = nouvel Ensemble [1..9]
	

Intersection, réunion, contraire

Le contraire de A est formé des résultats qui sont dans l'univers mais pas dans A; on l'obtient par

A.complémentDans univers

L'évènement «le résultat est pair, et en plus il s'écrit avec un seul chiffre», noté A ∩ B, s'obtient par

A.inter B

L'évènement «le résultat est pair, ou alors il s'écrit avec un seul chiffre (à moins que ce soit les deux en même temps)», noté A ∪ B, s'obtient par

A.union B

Crible d'Eratosthène

Pour chercher les nombres premiers inférieurs ou égaux à 200, on peut faire ainsi :

crible = nouvel Ensemble [1..200]
pour m dans [2..200]
    poubelle = nouvel Ensemble (x pour x dans crible.support quand x>m et x%m == 0)
    crible = poubelle.complémentDans crible

affiche crible

En fait, on peut aussi implémenter cet algorithme avec des tableaux, ce qui permet alors d'afficher l'histogramme des nombres premiers :

N = 200
crible = [2..N]
pour m dans [2..N]
    poubelle = (x pour x dans crible quand x>m et x%m est égal à 0)
    crible = (x pour x dans crible quand x n'est pas dans poubelle)

histogramme crible, 0, 200, 10, 10
020406080100120140160180

Probabilité

Le nombre d'éléments que contient un ensemble est son cardinal; pour savoir combien d'éventualités se trouvent dans A, on fait

A.cardinal()

Si son cardinal est nul, A est l'évènement impossible (le contraire de l'univers); pour savoir si un ensemble est vide, on fait

A.estVide()

La probabilité d'un évènement A est définie comme le quotient de son cardinal par celui de l'univers; elle dépend donc du choix de l'univers, et se note PΩ(A), ou, lorsqu'il n'y a pas d'ambigüité sur Ω, simplement P(A):

univers = nouvel Ensemble [1..20]
proba = (E) -> E.probaSachantQue univers
B = nouvel Ensemble [1..9]
affiche proba(B)

Géométrie plane

Pour créer un point, on demande un nouveau Point (avec un P majuscule) et on lui donne des coordonnées :

A = nouveau Point 30, 20

Affichage

Les coordonnées de A s'affichent avec affiche A. Pour dessiner A dans un repère centré sur le graphique et d'unité 1 pixel, il faut faire

effaceDessin()
A = nouveau Point 30, 20
dessineCercle 320+A.x, 240-A.y, 2, 'blue'
En effet A.x et A.y sont les coordonnées de A.

Segment

Distance

La distance AB se calcule avec :

A = nouveau Point 30, 20
B = nouveau Point -50, 20
affiche A.distance B

Milieu

Pour calculer les coordonnées du milieu de [AB] :

A = nouveau Point 30, 20
B = nouveau Point -50, 20
affiche A.milieu B

Dessin

Pour dessiner le segment [AB] en vert :

A = nouveau Point 30, 20
B = nouveau Point -50, 20
dessineSegment 320+A.x, 240-A.y, 320+B.x, 240-B.y, 'green'

Vecteur

Les coordonnées du vecteur d'origine A et d'extrémité B se calculent avec

A = nouveau Point 30, 20
B = nouveau Point -50, 20
affiche A.vecteur B

Vecteurs du plan

Création et affichage

Pour créer un nouveau vecteur, on doit juste entrer ses coordonnées :

u = nouveau Vecteur 3, 2
affiche u
On voit que l'affichage des vecteurs se fait juste en demandant d'afficher. On constate aussi l'utilité de nommer les vecteurs, pour référence ultérieure.

Norme

La norme (ou longueur) d'un vecteur est une méthode de celui-ci :

u = nouveau Vecteur 3, 2
affiche u.norme()

Opérations

Multiplication par un réel

Pour tripler un vecteur :

u = nouveau Vecteur 3, 2
affiche u.fois 3

Somme de vecteurs

Pour additionner deux vecteurs, on utilise plus :

u = nouveau Vecteur 3, 2
v = nouveau Vecteur -1, 5
affiche u.plus v

Produit scalaire

Pour multiplier (scalairement) un vecteur par un autre, on utilise scalaire :

u = nouveau Vecteur 3, 2
v = nouveau Vecteur -1, 5
affiche u.scalaire v

Cela sert à savoir si des vecteurs sont perpendiculaires :

u = nouveau Vecteur 3, 2
v = nouveau Vecteur -1, 5
affiche u.orthogonal v

Déterminant

Le déterminant d'un vecteur avec un autre vecteur est un nombre :

u = nouveau Vecteur 3, 2
v = nouveau Vecteur -1, 5
affiche u.déterminant v

Cela sert à savoir si deux vecteurs sont colinéaires :

u = nouveau Vecteur 3, 2
v = nouveau Vecteur -1, 5
affiche u.colinéaireAvec v

Pour aller plus loin, voir l'aide sur les matrices et les exemples de géométrie dans l'espace.

Graphisme

La sortie graphique mesure 640 pixels de large et 480 pixels de haut. Les abscisses vont donc de 0 (tout à gauche) jusqu'à 640 (tout à droite); mais les ordonnées sont ordonnées de haut en bas: 0 pour un élement graphique tout en haut, et 480 pour un élément graphique tout en bas.

Gomme

Pour effacer le dessin, on entre

effaceDessin()

Pour exporter le dessin :

$("#sortieSVG").text $("#graphique").html()

Ensuite, copier-coller le contenu du champ texte qui est en-dessous du graphique, vers un éditeur de texte; sauvegarder le résultat avec une extension .svg.

Point

On dessine un point comme un cercle de rayon petit, par exemple

dessineCercle 240, 100, 2, 'red'

pour dessiner le point de coordonnées (240,100) (représenté comme un cercle de rayon 2 pixels).

Segment

Pour dessiner le segment joignant les points de coordonnées respectives (100, 200) et (400, 300) :

dessineSegment 100, 200, 400, 300, 'blue'

Rectangle

Pour dessiner le rectangle dont le coin supérieur gauche a pour coordonnées (200,50) et de largeur 40 pixels, et de hauteur 150 pixels:

dessineRectangle 200, 50, 40, 150, 'cyan'

Texte

Pour écrire sur le graphique (aux coordonnées (150,100) ici), on fait

dessineTexte "alcoffeethmique Mac", 150, 100, 'grey'

On peut choisir la couleur que l'on veut pour chacune de ces primitives graphiques. Le format est le suivant: Une chaîne de caractères commençant par "#" suivi de 6 lettres (ou chiffres hexadécimaux) allant de 0 à f, les deux premier codant la quantité de rouge (de 00 à ff), les deux suivants codant la quantité de vert, et les deux derniers codant la quantité de bleu. Par exemple, pour avoir du jaune, on peut faire "#ffff00" ou "yellow".

Polygone

Pour dessiner un polygone, il faut lui fournir la liste des coordonnées de ses sommets (chacun des éléments de cette liste est lui-même une liste de deux nombres), ainsi que la couleur du périmètre et celle du remplissage (none si on ne veut pas remplir)

dessinePolygone [[20,240],[600,20],[600,460]], 'black', 'yellow'

Graphiques élaborés

Axes

Axe des abscisses

Pour dessiner l'axe gradué des abscisses allant de -1 à 3, en mauve :

dessineAxeX -1, 3, 'magenta'

et de façon similaire pour l'axe des ordonnées (dessineAxeY); on peut dessiner d'un coup les deux axes avec

dessineAxes -1, 3, -10, 100, 'brown'

Ces fonctions sont utilisées dans les deux suivantes:

Représentation graphique d'une fonction

Pour représenter graphiquement la fonction carré sur [-10,10] :

dessineFonction carré, -10, 10, 0, 100, 'red'
-10-9-8-7-6-5-4-3-2-10123456789100102030405060708090100

Représentation graphique d'une suite

Pour représenter graphiquement une suite, il faut la calculer comme une liste de nombres; par exemple, pour représenter graphiquement la somme des n premiers entiers (c'est une suite d'entiers) pour n allant de 0 à 10, avec des points de rayon 3, en bleu :

dessineSuite (laSommeDe [1..k] pour k dans [0..20]), 10, 0, 60, 3, 'blue'
0123456789100102030405060

Graphiques statistiques

Diagramme en bâtons
diagrammeBatons {'pour': 25, 'contre': 60, 'sans opinion': 15}, 100

Le second paramètre est un facteur d'échelle sur l'axe des ordonnées

Variante si le caractère est quantitatif:

lancers = nouveau Sac []
lancers.ajoute dé(6) pour n dans [1..100]
diagrammeBatonsTrie lancers.effectifs , 40
Histogramme

Pour dessiner un histogramme, il faut une liste de nombres, les bornes d'un intervalle et le nombre de rectangles :

carrés = (x*x pour x dans [0..100])
histogramme carrés, 0, 10000, 10, 40
0100020003000400050006000700080009000

Statistiques

Pour faire des statistiques sur une liste, il est parfois nécessaire de la trier (par exemple, pour calculer les quantiles). Comme "trier" se dit "sort" en anglais, on trie la liste L ainsi:

Tri dans l'ordre croissant

L.sort (x,y) -> (y-x)
	

Tri dans l'ordre décroissant

	L.sort (x,y) -> (x-y)
	

Maximum et minimum

Math.max.apply  null,L
Math.min.apply  null,L

Pour connaître l'effectif total d'une liste, on peut utiliser sa "longueur" (en anglais, length):

Compter les éléments d'une liste

L.length

Somme des éléments d'une liste

laSommeDe L

Moyenne d'une liste

laMoyenneDe L

Variance et écart-type

laVarianceDe L
lEcartTypeDe L

Médiane

laMédianeDe

Nombres complexes

Définition

Pour créer le complexe z=3+2i, on entre juste

z = nouveau Complexe 3, 2
Sa partie réelle est z.Re et sa partie imaginaire est z.Im.

Fonctions

Conjugué

Pour calculer le conjugué de 3+2i:

z = nouveau Complexe 3, 2
affiche z.conj()

Inverse

L'inverse de z est z.inverse():

z = nouveau Complexe 3, 4
affiche z.inverse()

Module

On peut calculer le module d'un nnombre complexe et le carré du module:

z = nouveau Complexe 3, 4
affiche z.module()
affiche z.modCarre()

Argument

L'argument d'un nombre complexe est donné en valeur principale en radians:

z = nouveau Complexe racine(3), 1
affiche z.argument()

Opérations

Addition

Pour additionner deux complexes on utilise ".plus" (attention au point):

a = nouveau Complexe 3, 2
b = nouveau Complexe 3, 4
affiche a.plus b

Soustraction

Pour soustraire deux complexes on utilise ".moins":

a = nouveau Complexe 3, 2
b = nouveau Complexe 3, 4
affiche a.moins b

Multiplication

Pour multiplier deux complexes on utilise ".fois":

a = nouveau Complexe 3, 2
b = nouveau Complexe 3, 4
affiche a.fois b

Division

Pour diviser deux complexes on utilise ".sur" (attention au point):

a = nouveau Complexe 3, 2
b = nouveau Complexe 3, 4
affiche a.sur b

Matrices

Vecteurs

Un vecteur est une liste de nombres; on le crée par le raccourci $V:

v = $V [2,1]
affiche v.elements

On voit au passage comment afficher les coordonnées d'un vecteur. On peut également engendrer des vecteurs aléatoires dont les coordonnées sont uniformes sur [0;1]:

u = Vector.Random(2)
affiche u.inspect()

On voit au passage une autre méthode d'affichage des coordonnées du vecteur

Coordonnées

L'abscisse de v se note v.e(1) et son ordonnée se note v.e(2). Pour additionner ou soustraire deux vecteurs:

u.add v
u.subtract v

Pour multiplier un vecteur par 3:

u.x 3

Coordonnées polaires

Pour calculer le produit scalaire de deux vecteurs, on utilise dot:

liste = (Vector.Random(2).dot(Vector.Random(2)) pour n dans [0...10000])
histogramme liste, 0, 2, 10, 4000

Ce script donne l'histogramme des produits scalaires de deux vecteurs aléatoires de coordonnées uniformes sur [0;1]:

00,20,40,60,811,21,41,61,82

Pour calculer la longueur d'un vecteur, on utilise modulus. Pour afficher la distribution statistique de la longueur d'un vecteur de coordonnées uniformes sur [0;1]:

liste = (Vector.Random(2).modulus() pour n dans [0...10000])
histogramme liste, 0, 1, 10, 2000

L'histogramme est surprenant:

00,10,20,30,40,50,60,70,80,91

Pour calculer l'angle entre deux vecteurs, on utilise angleFrom():

liste = (Vector.Random(2).angleFrom(Vector.Random(2)) pour n dans [0...10000])
histogramme liste, 0, 2, 10, 4000

Ce script affiche l'histogramme des angles entre deux vecteurs:

00,20,40,60,811,21,41,61,82

Pour faire tourner un vecteur v d'un angle a (en radians), faire

u = $V [1,0]
a = pi/6
affiche (u.rotate a, $V [0,0]).inspect()

Matrices

Définition

Une matrice est un vecteur de vecteurs:

M = $M [[1,2], [3,4]]
affiche M.inspect()

On engendre donc une matrice avec $M suivi du tableau, et on l'affiche avec inspect(). Il y a d'autres moyens d'engendrer des matrices:

M = Matrix.Diagonal [1,2]
M = Matrix.Zero 2, 2
M = Matrix.I(2)
M = Matrix.Random 2, 2
M = Matrix.Rotation pi/3

On peut récupérer les éléments d'une matrice avec e(i,j), les lignes avec row(i) et les colonnes avec col(j)

Opérations

Pour additionner deux matrices, on utilise add comme pour les vecteurs. De même on peut soustraire deux matrices avec subtract et multiplier une matrice par un nombre avec x; la syntaxe est la même que pour les vecteurs.

Pour multiplier deux matrices (et arrondir le résultat pour qu'il soit plus lisible):

M = Matrix.Rotation pi/3
P = Matrix.Rotation pi/6
affiche (M.multiply P).inspect()
affiche ((M.multiply P).snapTo 0).inspect()

Trace et déterminant

Pour afficher les éléments diagonaux d'une matrice:

M = Matrix.Rotation pi/3
affiche M.diagonal().inspect()

Pour afficher la transposée:

M = Matrix.Rotation pi/3
affiche M.transpose().inspect()

Pour afficher la trace et le déterminant:

M = Matrix.Rotation pi/3
affiche M.trace()
affiche M.determinant()

Pour obtenir l'inverse d'une matrice:

M = Matrix.Rotation pi/3
affiche M.inverse().inspect()

Systèmes d'équations

Le principe est le suivant: On écrit le système sous la forme AX=B, où X et B sont des vecteurs colonne, et A une matrice carrée. Alors la solution du système, écrite sous forme d'un vecteur colonne, est X=A'B où A' est l'inverse de A. Par exemple, pour résoudre le système formé par les deux équations 3x-2y=-1 et x+y=8:

A = $M [[3,-2],[1,1]]
B = $V [-1,8]
affiche (A.inv().x B).inspect()

Exemples

Syracuse

Personne ne sait encore si cet algorithme s'arrête au bout d'un temps fini pour toute valeur initiale entière u0:

suite de Collatz

u = 35
jusqu'à ce que u == 1
    si u%2 est égal à 0
        u /= 2
    sinon
        u = 3*u+1
    affiche u
	

Graphique

u = 35
Collatz = [u]
jusqu'à ce que u == 1
    si u%2 est égal à 0
        u /= 2
    sinon
        u = 3*u+1
    Collatz.push u

Syr = {}
pour n dans [0...Collatz.length]
    Syr[n]=Collatz[n]
trierDansTableau Syr

dessineSuite Collatz, Collatz.length-1, 0, 200, 3, 'red'
0123456789101112130102030405060708090100110120130140150160170180190200

temps de vol

vol = (n) ->
    [u, temps] = [n, 0]
    jusqu'à ce que u == 1
        si u%2 est égal à 0
            u /= 2
        sinon
            u = 3*u+1
        temps++
    temps

affiche (vol n pour n dans [2..20])
	

Algorithme d'Euclide

Pour calculer le pgcd de deux nombres a et b, on remplace a et b par b et r jusqu'à ce que r soit nul (r est le reste de la division de a par b).

version classique:

pgcd = (a,b) ->
    [x,y] = [a,b]
    jusqu'à ce que y == 0
        [x,y]=[y,x%y]
    x

affiche pgcd 55,34
	

Version CoffeeScript:

pgcd = (x,y) ->
    [x,y]=[y,x%y] jusqu'à ce que y == 0
    x

affiche pgcd 55,34
	

Calcul de racines carrées par l'algorithme de Heron

Pour calculer la racine carrée de 5 par l'algorithme de Heron, on remplace une valeur approchée a (par défaut), par sa moyenne avec 5/a (valeur approchée par excès); et on recommence jusqu'à ce que la différence entre les valeurs approchées par défaut et par excès soit devenue imperceptible.

Calcul de √(5)

[a,b] = [1,5]
jusqu'à ce que -1e-16 < b-a < 1e-16
    a=(a+b)/2
    b=5/a
affiche a
	

Représentation graphique

En plaçant les approximations successives de √(2) dans un tableau, on peut les représenter graphiquement, pour vérifier la convergence :

u=[1]
pour n dans [1..20]
    u[n] = (u[n-1]+2/u[n-1])/2

dessineSuite u, 20, 0, 2, 5, 'red'
01234567891011121314151617181900,10,20,30,40,50,60,70,80,911,11,21,31,41,51,61,71,81,9

Fractions

Une autre version, avec l'utilisation de fractions:

deux = nouvelle Fraction 2
cinq = nouvelle Fraction 5
[a,b]=[nouvelle Fraction(1),nouvelle Fraction(5)]
pour n dans [1..12]
    a=a.plus(b).sur(deux)
    b=cinq.sur(a)
    affiche a.toFloat()

Une légère modification fournit une suite d'approximations rationnelles de la racine de 5:

deux = nouvelle Fraction 2
cinq = nouvelle Fraction 5
[a,b]=[ nouvelle Fraction(1), nouvelle Fraction(5)]
pour n dans [1..12]
    a=a.plus(b).sur(deux)
    b=cinq.sur(a)
    affiche a

De même, l'algorithme est aisément transposable aux nombres complexes:

deux = nouveau Complexe 2
cinq = nouveau Complexe 5
[a,b] = [ nouveau Complexe(1), nouveau Complexe(5)]
jusqu'à ce que b.moins(a).module() < 1e-8
    a=a.plus(b).sur(deux)
    b=cinq.sur(a)
affiche a
	

Fonction racine carrée

racineDe = (x) ->
    [a,b] = [1,x]
    jusqu'à ce que (abs b-a) < 1e-16
        a=(a+b)/2
        b=x/a
    a
    
affiche racineDe 5
Erreur d'approximation

La différence entre racineDe(x) et la "vraie" racine carrée de x dépend fortement de x :

racineDe = (x) ->
    [a,b]=[1,x]
    jusqu'à ce que (abs b-a) < 1e-5
        a=(a+b)/2
        b=x/a
    a
    
erreur = (x) -> racineDe(x) - racine(x)
	
dessineFonction erreur, 0.1, 20, 0, 1e-5, 'blue'
01234567891011121314151617181900,0000010,0000020,0000030,0000040,0000050,0000060,0000070,0000080,000009

Tables trigonométriques

Table de sinus

au degré près:

arr3 = (x) -> arrondi(1000*x)/1000

affiche "|angle|sinus|"
affiche "|#{n}    |#{arr3 sinus n} |" pour n dans [0..90]
	

à la minute près:

	arr3 = (x) -> arrondi(1000*x)/1000

affiche "|angle|sinus|"
affiche "|#{arr3 n}    |#{arr3 sinus n} |" pour n dans [0..1] par pas de 1/60
	

Remarque: On peut aussi faire

tableauValeurs sinus, [0..20]
	

Table de cosinus

arr3 = (x) -> arrondi(1000*x)/1000

affiche "|angle|cosinus|"
affiche "|#{n}    |#{arr3 cosinus n} |" pour n dans [0..90]	
	

Équations

Dichotomie

L'algorithme de dichotomie est efficace pour résoudre l'équation f(x)=0

f = (x) -> ln(x) - 1

[a,b]=[1,10]
jusqu'à ce que b-a < 0.000001
    m=(a+b)/2
    si f(m) < 0
        a = m
    sinon
        b = m
    affiche [a,b]
	

Équations du second degré

Résoudre une équation, c'est donner la liste de ses solutions; pour le second degré, il y a 0, 1 ou 2 solutions selon le signe du discriminant Δ :

SecondDegré = (a,b,c) ->
    S = nouvel Ensemble []
    Delta = b*b-4*a*c
    r = laRacineDe Delta
    S.ajoute (-b-r)/(2*a)
    S.ajoute (-b+r)/(2*a)
    S

affiche SecondDegré 1, 2, 1
	

Et au cas où Δ est négatif, on peut résoudre l'équation sur les complexes :

SecondDegré = (a,b,c) ->
    S = nouvel Ensemble []
    Delta = b*b-4*a*c
    si Delta >= 0
        r = laRacineDe Delta
        S.ajoute (-b-r)/(2*a)
        S.ajoute (-b+r)/(2*a)
    sinon
        r = nouveau Complexe 0, laRacineDe -Delta
        d = nouveau Complexe 2*a
        m = nouveau Complexe -b
        S.ajoute m.moins(r).sur(d)
        S.ajoute m.plus(r).sur(d)
    S

affiche SecondDegré 1, -1, 1

Suites géométriques

Combien de fois faut-il lancer un dé équilibré pour que la probabilité d'avoir un 6 dépasse 0,99 ?

La condition de sortie se traduisant par le fait que la probabilité de ne pas avoir de 6 est en-dessous de 0,01; et comme si les lancers sont indépendants, cette probabilité suit une suite géométrique de raison 5/6:

proba = 1
nombreDeLancers=1
jusqu'à ce que proba < 0.01
    proba *= 5/6
    nombreDeLancers++
affiche "En lançant #{nombreDeLancers} fois le dé, la probabilité d'avoir un 6 vaut #{1-proba}"
	

Représentation graphique

On construit une liste (ou tableau) des termes successifs de la suite, pour représenter graphiquement celle-ci. On remarque comme comme sa raison est inférieure à 1, la valeur maximale est 1; donc on choisit 0 pour yMin et 1 pour yMax :

u=[1]
pour n dans [1..20]
    u[n]=5/6*u[n-1]

dessineSuite u, 20, 0, 1, 5, 'red'
01234567891011121314151617181900,10,20,30,40,50,60,70,80,9

Briggs

Algorithme de Briggs pour calculer des logarithmes

log = (x) ->
    si x > 0
        [r,n] = [x,0]
        jusqu'à ce que 0.999999 < r < 1.000001
            n++
            r=racine r
        r -= 1
        r *= 2 pour k dans [1..n]
        r


affiche log 2.7182818
	

Erreur d'approximation

En calculant un logarithme par l'algorithme de Briggs, on commet une erreur d'approximation (la différence entre log(x) et ln(x)) qui dépend de x; sa représentation graphique permet de voir comment :

log = (x) ->
    si x > 0
        [r,n] = [x,0]
        jusqu'à ce que 0.999999 < r < 1.000001
            n++
            r = racine r
        r -= 1
        r *= 2 pour k dans [1..n]
        r

erreur = (x) -> log(x)-ln(x)

dessineFonction erreur, 0.1, 10, 0, 0.000002, 'blue'

	
01234567891001e-72e-73e-74e-75e-76e-77e-78e-79e-70,0000010,00000110,00000120,00000130,00000140,00000150,00000160,00000170,00000180,00000190,000002

Suite de Fibonacci

La suite Fn est définie par la relation de récurrence Fn+2=Fn+1+Fn. Si F0=F1=1, la suite est entièrement déterminée.

Version classique

[a,b] = [1,1]
pour n dans [1..10]
    [a,b] = [a+b,a]
    affiche "F(#{n})=#{b}"
	

Formule de Binet

nombreDor = (1 + racine 5)/2 
pour n dans [1..10]
    b = puissance nombreDor, n
    b /= racine 5
    b = arrondi b
    affiche "F(#{n})=#{b}"

Représentation graphique

Pour représenter graphiquement la suite de Fibonacci, on met ses termes successifs dans un tableau. Ce qui revient à les pousser l'un après l'autre dedans :

u = [1,1]
pour n dans [2..30]
    u[n]=u[n-2]+u[n-1]

dessineSuite u, 10, 0, 100, 5, 'red'
0123456789100102030405060708090100

Problème du Grand-Duc de Toscane

Lorsque Galilee lui donnait des cours, Cosme de Medicis, futur Grand-Duc de Toscane, lui a demandé comment ça se fait que lorsqu'on additionne les résultats de 3 dés, le 10 sort plus souvent que le 9, alors que

  • 9=1+2+6=1+3+5=1+4+4=2+2+5=2+3+4=3+3+3
  • 10=1+3+6=1+4+5=2+2+6=2+3+5=2+4+4=3+3+4
soit 6 manières dans chaque cas.

Simulation

stats = nouveau Sac []
pour n dans [1..100000]
    stats.ajoute dé(6)+dé(6)+dé(6)
trierDansTableau stats.effectifs
diagrammeBatonsTrie stats.effectifs, 20000
3456789101112131415161718

Calcul des probabilités

loi = nouveau Sac []
loi.ajoute(a+b+c) pour a dans [1..6] pour b dans [1..6] pour c dans [1..6]
d = puissance 6, 3
affiche "La probabilité d'avoir un 9 vaut #{loi.effectifs[9]/d}"
affiche "La probabilité d'avoir un 10 vaut #{loi.effectifs[10]/d}"
	

Problème du Chevalier de Méré

Dans une lettre à Blaise Pascal, le Chevalier de Méré lui a posé la question suivante: Comment se fait-il qu'en lançant 4 dés, on a plus d'une chance sur 2 d'avoir au moins un 6 ?

Simulation du lancer de 4 dés

gains = 0
pour n dans [1..100000]
    jeu=(dé(6) pour n dans [1..4])
    si (x pour x dans jeu quand x est égal à 6).length
        gains++
affiche gains/100000

Calcul de la probabilité

gains=0
pour a dans [1..6]
    pour b dans [1..6]
        pour c dans [1..6]
            pour d dans [1..6]
                si a == 6 ou b == 6 ou c == 6 ou d == 6
                    gains++
d = puissance 6, 4
affiche gains/d

Avec une suite géométrique

Comme la probabilité de ne pas avoir de 6 en lançant un dé est 5/6, et par indépendance des lancers de dés, la probabilité de na pas avoir de 6 en lançant 4 dés est le quatrième terme d'une suite géométrique de premier terme 5/6 et de raison 5/6:

u = 1
(u *= 5/6 pour n dans [1..4])
affiche 1-u

jeu de Dada

Au jeu de Dada (ou des "petits chevaux") on lance un dé jusqu'à ce qu'on ait un 6. Alors seulement, le petit cheval peut "sortir de l'écurie" (on peut commencer à jouer)

Loi géométrique

La variable aléatoire "nombre de fois qu'on doit lancer le dé pour avoir un 6" suit une loi géométrique de paramètre 1/6. Pour la simuler:

X = 0
X++ jusqu'à ce que dé(6) == 6
affiche X

Pour jouer plusieurs fois aux petits chevaux, on peut refaire tout ça dans une boucle; on en profite pour faire un tableau d'effectifs:

stats = nouveau Sac []
pour n dans [1..100]
    X = 0
    X++ jusqu'à ce que dé(6) == 6
    stats.ajoute X

trierDansTableau stats.effectifs
diagrammeBatonsTrie stats.effectifs, 20
0123456789101113141516181923

Loi géométrique tronquée

La probabilité que l'algorithme précédent s'arrête au bout d'un temps fini est 1. Néanmoins, on prend moins de risque à tronquer X, en remplaçant tous les X supérieurs à 20 par des 0:

stats = nouveau Sac []
pour n dans [1..100]
    X = 0
    X++ jusqu'à ce que dé(6) == 6
    X = 0 si X > 20
    stats.ajoute X

trierDansTableau stats.effectifs
diagrammeBatonsTrie stats.effectifs, 20
	
012345678910111213141516

Poker avec 32 cartes

Tirer 5 cartes (une "main") dans un jeu de 32 cartes, c'est constituer un échantillon d'effectif 5 dans une population totale de 32. C'est donc la base de la statistique.

On vérifie que les 4 couleurs sont équiprobables :

couleur=['♦','♥','♠','♣']
urne = nouveau Sac
urne.ajoute prendreAuHasardDans couleur pour n dans [1..1000]

mettreDansTableau urne.effectifs
diagrammeBatons urne.effectifs
	

Les 4 couleurs ont bien l'air équiréparties :

Tirage de 5 cartes

Tirage avec remise

Si on répète 5 fois l'expérience de tirer une carte, on risque d'avoir plusieurs fois la même carte (tirage avec remise). Mais ce risque est minime:

couleur=['♦','♥','♠','♣']
valeur=['1','7','8','9','10','V','D','R']
jeu=[]
pour c dans couleur
    pour v dans valeur
      jeu.empile "#{v}#{c}"

main = tirageAvecRemise 5, jeu
affiche main
Tirage sans remise
couleur=['♦','♥','♠','♣']
valeur=['1','7','8','9','10','V','D','R']
jeu=[]
pour c dans couleur
    pour v dans valeur
      jeu.empile "#{v}#{c}"

main = tirageSansRemise 5, jeu
affiche main

Cas particulier: Pour mélanger le jeu, on fait un tirage sans remise de 32 cartes :

couleur = ['♦','♥','♠','♣']
valeur = ['1','7','8','9','10','V','D','R']
jeu = []
pour c dans couleur
    pour v dans valeur
      jeu.empile "#{v}#{c}"

affiche mélangée jeu

Calcul de probabilités

Pour savoir quelle est la probabilité d'avoir un carré d'as,

  • le nombre de cas possibles est le nombre de choix de 5 cartes parmi 32
  • le nombre de cas favorables est le nombre de choix de la cinquième carte (les 4 autres sont des as) parmi 28 (celles qui restent une fois qu'on a enlevé les as) :

casPossibles = combinaison 32, 5
casFavorables = combinaison 28, 1

affiche casFavorables/casPossibles

Bien entendu on peut aussi avoir la valeur exacte de la probabilité:

casPossibles = combinaison 32, 5
casFavorables = combinaison 28, 1

affiche nouvelle Fraction casFavorables, casPossibles
On peut exprimer le résultat en disant qu'on a une chance sur 7192 d'avoir un carré d'as.

loi binomiale

La loi B(10,0.7) est la loi du nombre de boules rouges dans un tirage (avec remise) dans une urne contenant 70 % de boules rouges.

Simulation

On peut utiliser deux sacs:

  • Le premier, urne, contient les boules rouges et bleues: C'est l'urne !
  • Le second, stats, contient les effectifs des nombres de boules rouges obtenues dans 100 tirages avec remise de 10 boules extraites du sac précédent.

urne = nouveau Sac []
urne.ajouteFois 70, 'rouge'
urne.ajouteFois 30, 'bleu'

stats = nouveau Sac []
stats.ajoute (urne.extraireAuHasard() pour n dans [1..10]).compteLes 'rouge' pour n dans [1..1000]

trierDansTableau stats.effectifs
diagrammeBatonsTrie stats.effectifs
	
345678910

Calcul de la loi binomiale

Pour afficher les valeurs prises par la loi binomiale de paramètres 10 et 0,7 (les probabilités), on peut faire

affiche (binomiale 10, 0.7, k pour k dans [0..10])

Intervalles de fluctuation

En tirant 200 boules (avec remise) dans une urne contenant 70 % de boules rouges, un intervalle de fluctuation à 95 % pour le nombre de boules rouges parmi les 200 s'obtient par

affiche IntFluctBinom 200, 0.7

Intervalles de confiance

Pour calculer un intervalle de confiance sur une proportion p, on utilise de l'algorithmique "de base" (pas de boucles): Affectations, entrées, sorties et éventuellement un test si on veut améliorer.

Version bac général

Cet algorithme simplifié est vu en Seconde et en Terminales L/ES et S

N = entre "Taille de l'échantillon ?"
ns = entre "Combien de succès ?"
p = ns/N
borneInférieure = p-1/laRacineDe N
borneSupérieure = p+1/laRacineDe N
affiche "Intervalle de confiance à 95 %: [#{borneInférieure};#{borneSupérieure}]"
	

Amélioration de l'algorithme

Deux problèmes peuvent se poser:

  1. La borne inférieure peut être négative; dans ce cas, on la remplace par 0.
  2. La borne supérieure peut être plus grande que 1; dans ce cas, on la tronque à 1.
L'algorithme amélioré peut s'écrire ainsi:
N = entre "Taille de l'échantillon ?"
ns = entre "Combien de succès ?"
p = ns/N
borneInférieure = p-1/laRacineDe N
borneInférieure = 0 si borneInférieure < 0
borneSupérieure = p+1/laRacineDe N
borneSupérieure = 1 si borneSupérieure > 1
if N > 24
    affiche "Intervalle de confiance à 95 %: [#{borneInférieure};#{borneSupérieure}]"
	

Version bac technologique

Cet algorithme, plus précis notamment lorsque la proportion de succès dans l'échantillon est proche de 0 ou de 1, est au programme des Terminales STL/STI2D et des BTS :

N = entre "Taille de l'échantillon ?"
ns = entre "Combien de succès ?"
p = ns/N
q = 1-p
borneInférieure = p-1.96*racine(p*q/N)
borneSupérieure = p+1.96*racine(p*q/N)
affiche "Intervalle de confiance à 95 % : [#{borneInférieure};#{borneSupérieure}]"
	

Version améliorée de la version bac technologique

Cette fois-ci, la formule n'est appliquée que si (avec les notations de l'algorithme), N×p et N×q sont tous les deux supérieurs à 5. De plus, l'échantillon doit être suffisamment grand (N≥25):

N = entre "Taille de l'échantillon ?"
ns = entre "Combien de succès ?"
p = ns/N
q = 1-p
borneInférieure = p-1.96*racine(p*q/N)
borneSupérieure = p+1.96*racine(p*q/N)
si N > 25 et N*p > 5 et N*q > 5
 affiche "Intervalle de confiance à 95 % : [#{borneInférieure};#{borneSupérieure}]"
sinon
    affiche "Il ne serait pas raisonnable de calculer un intervalle de confiance avec ces données"

Graphisme

Ne pas oublier, de temps en temps, de faire effaceDessin() pour vider le graphique.

Tableau de fils

pour n dans [1..100] par pas de 2
    x1 = 100+4*n
    y1 = 440
    x2 = 100
    y2 = 40+4*n
    dessineSegment x1, y1, x2, y2, 'black'

étoile

sommets = []
pour n dans [0...17]
    angle = n*8/17*360
    sommets.empile [320+200*cosinus(angle),240+200*sinus(angle)]
dessinePolygone sommets, 'blue', 'green'

Néphroïde

N = 24
pour n dans [0...N]
    angle = n/N*360
    cx = 320 + 100*cosinus(angle)
    cy = 240 + 100*sinus(angle)
    dessineCercle cx, cy, abs(100*sinus(angle)), 'blue'

Triangle de Sierpinski

Version itérative (nuage de points)
A = nouveau Point 50, 240
B = nouveau Point 600, 20
C = nouveau Point 600, 460
M = nouveau Point dé(640), dé(480)
pour n dans [1..1000]
    selon dé(3)
        quand 1
            M = M.milieu A
            dessineCercle M.x, M.y, 2, 'red'
        quand 2
            M = M.milieu B
            dessineCercle M.x, M.y, 2, 'blue'
        sinon
            M = M.milieu C
            dessineCercle M.x, M.y, 2, 'green'
Version récursive
A = nouveau Point 50, 240
B = nouveau Point 600, 20
C = nouveau Point 600, 460
gasket = (a,b,c,N) ->
    si N < 1
        dessinePolygone [[a.x,a.y],[b.x,b.y],[c.x,c.y]], 'black', 'none'
    sinon
        gasket(a, a.milieu(b), a.milieu(c), N-1)
        gasket(b, b.milieu(c), b.milieu(a), N-1)
        gasket(c, c.milieu(a), c.milieu(b), N-1)

gasket A, B, C, 6

Géométrie dans l'espace

Sujet du bac S Liban 2014

Pour chacune des propositions suivantes, indiquer si elle est vraie ou fausse et justifier chaque réponse. Une réponse non justifiée ne sera pas prise en compte.

On se place dans l’espace muni d’un repère orthonormé. On considère le plan P d’équation x − y + 3z + 1 = 0 et la droite D dont une représentation paramétrique est

  • x = 2t
  • y = 1+t
  • z = -5+3t

On donne les points A(1 ; 1; 0), B(3 ; 0 ; −1) et C (7 ; 1 ; −2).

Pour entrer les définitions, on découvre rapidement que le plan P passe par le point de coordonnées (0,-1,0) et on lit sur son équation les coordonnées d'un vecteur normal de P; de même, on lit dans la représentation paramétrique de D les coordonnées (0,1,-5) d'un point et les coordonnées (2,1,3) d'un vecteur directeur. On utilise les notations $V pour les points (qui sont traités comme des vecteurs), $L pour les droites (comme "line") et $P pour les plans:

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]

Proposition 1 :

Une représentation paramétrique de la droite (AB) est
  • x = 5-2t
  • y = -1+t
  • z = -2+t

Pour vérifier ceci, on crée une droite qu'on appelle AB à partir de la représentation paramétrique puis on vérifie qu'elle passe par A et par B:

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
AB = $L [5,-1,-2], [-2,1,1]
affiche AB.contains A
affiche AB.contains B

Comme la droite "AB" passe par A et par B, c'est bien la droite (AB)...

Proposition 2 :

Les droites D et (AB) sont orthogonales.

On va vérifier que les vecteurs directeurs des deux droites sont perpendiculaires :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
AB = $L [5,-1,-2], [-2,1,1]
affiche D.direction.isPerpendicularTo AB.direction

Proposition 3 :

Les droites D et (AB) sont coplanaires.

On regarde si elles sont parallèles (auquel cas elles sont coplanaires, mais on a vu dans la proposition 2 qu'elles ne sont pas parallèles), et si elles sont sécantes, auquel cas elles sont coplanaires :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
AB = $L [5,-1,-2], [-2,1,1]
affiche D.isParallelTo AB
affiche D.intersects AB

Proposition 4 :

La droite D coupe le plan P au point E de coordonnées (8; −3; −4).

On va d'abord vérifier que D coupe P :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
AB = $L [5,-1,-2], [-2,1,1]
affiche D.intersects P

Maintenant que c'est fait, on va chercher où ils se coupent :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
AB = $L [5,-1,-2], [-2,1,1]
affiche ((D.intersectionWith P).map (x)-> arrOdg x, 6).inspect()

Apparemment, D et P se coupent mais pas en E, les coordonnées du point d'intersection étant (3, 2.5, -0.5). On va vérifier que, si P passe par E, ce n'est pas le cas de D :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
AB = $L [5,-1,-2], [-2,1,1]
E = $V [8,-3,-4]
affiche D.contains E
affiche P.contains E

D'ailleurs, on peut avoir les coordonnées (approximatives) du point de D le plus proche de E :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
AB = $L [5,-1,-2], [-2,1,1]
E = $V [8,-3,-4]
affiche (D.pointClosestTo E).inspect()

Proposition 5 :

Les plans P et (ABC ) sont parallèles.

On définit le plan (ABC) par un de ses points (le point A) et deux de ses vecteurs, ceux allant de A respectivement à B et à C. Puis on regarde si ce plan est parallèle à P :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
ABC = $P A, B.subtract A, C.subtract A
affiche P.isParallelTo ABC

On peut aussi vérifier que les trois points A, B et C sont à la même distance de P :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
ABC = $P A, B.subtract A, C.subtract A
affiche (P.distanceFrom point for point in [A,B,C])

Bien bien bien, ils ne sont pas parallèles. Mais alors, dans ce cas, ils sont sécants ! Et puisqu'ils sont sécants, leur intersection est une droite dI. On peut obtenir un point et un vecteur directeur de cette droite :

P = $P [0,1,0], [1,-1,3]
D = $L [0,1,-5], [2,1,3]
A = $V [1,1,0]
B = $V [3,0,-1]
C = $V [7,1,-2]
ABC = $P A, B.subtract A, C.subtract A
dI = P.intersectionWith ABC
affiche [dI.anchor.inspect(), dI.direction.x(1).inspect()]

On parle de récursivité lorsqu'un algorithme fait appel à lui-même.

Récursivité

Définition récursive de la puissance

La définition revient à dire que

  • a0=1
  • an=a×an-1 sinon

puissRec = (base, exposant) ->
    si exposant est égal à 0
        1
    sinon
        base*puissRec base, exposant-1

affiche puissRec 2, 8

Définition récursive de la factorielle

La factorielle de 0 est définie comme étant 1; sinon, n! = n × (n-1)!

factorielleRec = (n) ->
    si n est égal à 0
        1
    sinon
        n*factorielleRec n-1

affiche factorielleRec 10

Jeu des tours de Hanoi

Le jeu des tours de Hanoï, inventé par Édouard Lucas, comprend trois "tours", sur lesquelles sont empilés des cylindres (ou "disques" épais) de taille décroissante, et le but du jeu est d'amener les cylindres de la tour "source" vers la tour "destination" (à l'aide d'une tour "intermédiaire"), en respectant les règles suivantes:

  • On ne déplace qu'un disque à la fois.
  • Déplacer un disque consiste à l'extraire du sommet d'une tour (le disque le plus haut) et le placer au sommet d'une autre tour.
  • On ne place jamais de disque au-dessus d'un disque plus petit que lui.
Par exemple, ci-dessous, on doit faire passer les trois disques de la tour de gauche à celle de droite, en utilisant la tour du milieu comme tour intermédiaire. Mettre le petit disque au milieu puis le disque suivant est interdit puisque le disque moyen est plus grand que le petit et ne doit pas être superposé à lui.

Une solution de ce jeu peut se décrire récursivement, avec l'algorithme suivant:

  • On joue aux tours de Hanoï avec les n-1 disques de la tour de gauche, en les empilant sur la tour du milieu, et en utilisant la tour de droite comme tour intermédiaire.
  • Alors il ne reste que le disque le plus grand à déplacer de la tour de gauche vers la tour de droite (qui est alors vide)
  • Puis on joue au jeu des tours de Hanoï entre les tours du milieu et de droite (on empile les n-1 disques sur le plus grand qui est passé à droite), en utilisant la tour de gauche comme tour intermédiaire.
L'algorithme se traduit ainsi:

hanoi = (n, source, interm, destination) ->
    si n est égal à 1
        affiche "Déplacer de #{source} vers #{destination}"
    sinon
        hanoi n-1, source, destination, interm
        hanoi 1, source, interm, destination
        hanoi n-1, interm, source, destination

hanoi 3, "gauche", "milieu", "droite"

Crédits

alcoffeethmique est un logiciel libre, et comme tel, il est basé sur d’autres logiciels libres, dont voici la liste :

  • CoffeeScript évidemment. Merci à son développeur Jeremy Ashkenas !
  • jQuery qui simplifie énormément la manipulation du fichier html sur lequel repose alcoffeethmique. Grosse équipe de développeurs qui se décarcassent pour nous !
  • jQuery-UI et ses « widgets » facilitant la vie de l’utilisateur. Là encore, trop de développeurs pour qu’on puisse les citer, bravo à eux tous.
  • jQuery UI « touch punch » qui permet aussi d’utiliser alcoffeethmique sur smartphone ou tablette. Développé par David Furfero, chapeau !
  • Underscore, développé par Jeremy Ashkenas (encore lui !) pour permettre aux javascriptiens de faire comme avec Ruby. Là encore, grand merci !
  • Big.js, permettant de faire des calculs en grande précision. Développé par « MikeMcl » tout seul, impressionnant !
  • Sylvester de James Coglan fait du calcul matriciel et vectoriel en dimensions 2 et 3. Sa concision rend les problèmes de géométrie analytique dans l’espace presque simples...
  • Voronoi de Raymond Hill, est une implémentation de l’algorithme de Steven Fortune en JavaScript [1]. Comme son nom l’indique, il calcule des domaines de Voronoï. Des exemples d’utilisation sont visibles dans cet article.

Certaines de ces extensions ne figurent pas dans la version en ligne ci-dessus, mais on les trouve dans la version hors ligne téléchargeable en haut de l’article, ainsi que des exemples cliquables.

Pour avoir la dernière version d’alcoffeethmique, aller sur son repository, cliquer sur clone or download puis dans le menu qui s’affiche alors, cliquer sur download zip. Ceci a pour effet de télécharger le dossier d’alcoffeethmique, que l’on doit alors dézipper pour accéder à l’intérieur du dossier, lequel comprend alors, entre autres, le fichier alcoffeethmique.html, à ouvrir avec un navigateur internet. Noter que cette dernière étape peut se faire en local et ne nécessite pas d’accès Internet.


[1Ce logiciel a été découvert par Eric Hakenholz qui, à l’époque, en avait fait des figures sous CaRMetal, animées par un « CarAScript » ou script d’action pour CaRMetal...


Documents joints

utilitaires.js
utilitaires.js
Zip - 313.5 ko
Zip - 313.5 ko
sylvester.js
sylvester.js
probas.js
probas.js
nombres.js
nombres.js
dessin.js
dessin.js

Portfolio

GIF - 497.4 ko

Commentaires

Logo de ProfGra
jeudi 14 mai 2015 à 20h09 - par  ProfGra

Bonjour,

Je suis tombé par hasard sur ce projet et cela m’a poussé à vous contacter.
J’ai essayé de vous envoyer des messages (Alain et Florian) sur vos pages d’auteur sur ce site, mais il y a eu un problème technique. Je réessaye ici.
Je voulais tout d’abord vous féliciter ! Bravo !
Ensuite je voulais émettre quelques remarques, que je préfère faire par email plutôt qu’ici.
Pour finir, je voulais vous présenter mon projet : http://microalg.info
et vous demander si je pourrais m’inspirer de quelques idées mises en place dans Alcoffeethmique pour MicroAlg.
Pas encore d’idée précise sur lesquelles incorporer, mais je voulais d’abord en parler.

À bientôt.

Annonces

Prochains rendez-vous de l’IREM

Séminaire EDIM-IREM

- Mercredi 13 septembre 2017, 14h-18h, PTU, Saint-Denis, salle S23.6
- Mercredi 4 octobre 2017, 14h-18h, PTU, Saint-Denis, salle S23.6
- Mercredi 11 octobre 2017, 14h-18h, campus du Tampon
- Mercredi 22 novembre 2017, 14h-18h, campus du Tampon
- Mercredi 7 février 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 7 mars 2018, 14h-18h, campus du Tampon
- Mercredi 4 avril 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 2 mai, 14h-18h, campus du Tampon
- Mardi 5 juin 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 6 juin, 14h-18h, campus du Tampon

Fête de la science

Du 13 au 18 novembre 2017.
Thème : « La recherche à l’heure du numérique »

Semaine des mathématiques

Du 26 au 31 mars 2018.
Thème : « Mathématiques et mouvement »


Brèves

Décès de Roger Mohr

mardi 27 juin

On sait bien que Nicolas Bourbaki n’était pas le nom d’une personne mais le pseudonyme d’un groupe. L’équivalent en informatique théorique est Claude Livercy, auteur de la théorie des programmes. Roger Mohr était un des membres de Claude Livercy.

À travers les labyrinthes : algorithmes et fourmis

dimanche 1er septembre 2013

Quand les chercheurs mettent au point des modèles d’optimisation et de recherche de plus court chemin qui s’inspirent du comportement de masse de colonies de fourmis...
À écouter : Sur les Épaules de Darwin, émission diffusée sur France Inter samedi 31 août 2013.

Rencontres Mondiales du Logiciel Libre à St-Joseph

mardi 20 août 2013

Les RMLLd se dérouleront pour la 2e fois à Saint-Joseph du 22 au 25 août.
C’est une opportunité pour les élèves qui suivent la spécialité ISN et les passionnés d’informatique.

Voici pour le samedi et le dimanche quelques interventions choisies :
- http://2013.d.rmll.info/Raspberry-votre-ordinateur-au-format-carte-de-credit?lang=fr
- http://2013.d.rmll.info/Materiel-libre-et-DIY?lang=fr
- http://2013.d.rmll.info/Arduino-de-l-electronique-libre?lang=fr

Noter aussi les conférences Art et Culture du dimanche, ainsi qu’une conférence plus engagée.

Le programme complet se trouve ici. Une radio sera ouverte pour l’occasion.
Des plaquettes à distribuer se trouvent ici.

Hyper-vidéos pour l’algorithmique au lycée

dimanche 19 août 2012

Olivier Roizès, à la demande de l’ADIREM, a réalisé une collection d’hyper-vidéos de présentation de logiciels et environnements de programmation. Ces hyper-vidéos, c’est-à-dire des vidéos contenant des éléments clicables, devraient être utiles aux enseignants désireux de se familiariser avec Python, CaRMetal, R, Rurple, Scilab ou Xcas.

Ouverture du SILO

mardi 1er novembre 2011

Le SILO (Science Informatique au Lycée : Oui !) est un espace collaboratif documentaire de partage et de formation collégiale, à destination des professeurs appelés à enseigner l’informatique au lycée.

Une initiative du CNDP, de l’INRIA et de Pasc@line, à laquelle se sont associés SPECIF, fuscia, EPI et ePrep.

Sur le Web : Site du SILO

Introduction à la science informatique

lundi 12 septembre 2011

Le CRDP de Paris publie le premier ouvrage destiné aux professeurs chargés d’enseigner la nouvelle spécialité « Informatique et sciences du numérique » en Terminale S à la rentrée 2012. Cet ouvrage a été coordonné par Gilles Dowek, directeur de recherche à l’INRIA.

Sur la création de la spécialité ISN, on pourra également consulter l’interview donnée au Café pédagogique par l’inspecteur général Robert Cabanne.

Sur le Web : CRDP de Paris

Deux publications sur l’algorithmique

samedi 17 octobre 2009

L’IREM d’Aix-Marseille publie une brochure de 73 pages, téléchargeable librement, intitulée Algorithmes et logique au lycée. Ces notions sont illustrées et déclinées sur des exercices du programme de spécialité mathématique en série L, mais sont adaptables aux programmes à venir.

Le hors série thématique n° 37 du magazine Tangente, disponible actuellement en kiosque, s’intitule « Les algorithmes. Au cœur du raisonnement structuré ». Extrait de l’éditorial : « La rédaction de Tangente a conçu la quasi-totalité de ce hors série thématique pour qu’il puisse être lu par des élèves de Seconde ».

Une carte mentale pour l’algorithmique

jeudi 10 septembre 2009

Sur son site, Jean-Jacques Dhénin a publié une carte mentale géante qui renvoie vers plus de 30 documents en ligne sur l’algorithmique. Tout ce qu’il faut — et même davantage — pour faire face au nouveau programme de Seconde !

Un catalogue libre d’algorithmes pour le lycée

dimanche 30 août 2009

Guillaume Connan, de l’IREM de Nantes, publie un catalogue libre de 119 pages d’algorithmes pour le lycée. Sur son site très riche, on trouvera d’autres documents en rapport avec l’algorithmique, notamment sur l’utilisation des langages fonctionnels au lycée et sur la comparaison programmation fonctionnelle/programmation impérative.

L’algorithmique à l’IREM de Lille

vendredi 26 juin 2009

Le groupe AMECMI de l’IREM de Lille vient de mettre en ligne des ressources importantes au service des professeurs de Seconde :

- Algorithmique et programmation (Emmanuel Ostenne)
- Bibliographie amoureuse de l’algorithmique (Alain Juhel)

Statistiques

Dernière mise à jour

lundi 25 septembre 2017

Publication

766 Articles
Aucun album photo
133 Brèves
11 Sites Web
132 Auteurs

Visites

319 aujourd'hui
1251 hier
2102814 depuis le début
41 visiteurs actuellement connectés