Members
(constant) apps :Object
- Source:
Nos applis prédéterminées avec la liste des fichiers à charger
Type:
- Object
autoCorrection
- Source:
********************* AMC Open
autoCorrection[undefined]
- Source:
********************* AMC Open
(constant) bissectriceAuCompas
Trace la bissectrice de l'angle ABC au compas.
(constant) carre1point1longueur
Macro crée par Sophie Desruelle
(constant) cercleCirconscrit
Construit les 3 médiatrices des côtés du triangle ABC puis le cercle circonscrit au triangle
(constant) choixDeroulant
(constant) dateDeModifImportante
- Source:
Modèle d'exercice très simple pour la course aux nombres
(constant) dateDeModifImportante
- Source:
Modèle d'exercice très simple pour la course aux nombres
(constant) demiTourPoint
(constant) demiTourPolygone
(constant) hauteur
Trace la hauteur issue de C dans un triangle ABC. Prolonge si besoin le segment [AB] pour avoir le pied de la hauteur et le codage de l'angle droit.
(constant) homothetiePoint
(constant) homothetiePolygone
(constant) mediane
Trace la médiane issue de C passant par le milieu de [AB]
(constant) mediatriceAuCompas
Trace la médiatrice de [AB] au compas. Le paramétrage des longueurs correspond à la distance entre le milieu du segment et le point d'intersection des arcs de cercles
(constant) mediatriceRegleEquerre
Trace la médiatrice du segment [AB] avec la méthode Règle + équerre.
(constant) paralleleAuCompas
(constant) paralleleAuCompasAvecDescription
(constant) paralleleRegleEquerre2points3epoint
Trace la parallèle à (AB) passant par C avec la règle et l'équerre. Peut prolonger le segment [AB] si le pied de la hauteur est trop éloigné des extrémités du segment
(constant) paralleleRegleEquerreDroitePointAvecDescription
Trace la parallèlee à (AB) passant par C avec la règle et l'équerre. Cette macro réalise la construction en décrivant ce qu'elle fait à chaque étape
(constant) perpendiculaireCompasPoint
Trace la perpendiculaire à une droite passant par un point n'appartenant pas à cette droite au compas.
(constant) perpendiculaireCompasPointSurLaDroite
Trace la perpendiculaire à une droite passant par un point de cette droite au compas.
(constant) perpendiculaireRegleEquerre2points3epoint
Trace la perpendiculaire à (AB) passant par C avec la règle et l'équerre. Peut prolonger le segment [AB] si le pied de la hauteur est trop éloigné des extrémités du segment Description désactivée par défaut.
(constant) perpendiculaireRegleEquerreDroitePoint
Construit à la règle et à l'équerre la perpendiculaire à une droite d passant par un point P n'appartenant pas à d. description désactivable.
(constant) perpendiculaireRegleEquerrePointSurLaDroite
Trace la perpendiculaire à une droite passant par un point de cette droite à l'équerre et à la règle.
(constant) rotationPoint
(constant) rotationPolygone
(constant) symetrieAxialePolygone
(constant) titre
- Source:
- Calcul mental autour des identités remarquables
- Clone de 3L11-5 pour les 2nde
- publié le 7/10/2021
(constant) titre
- Source:
- Calcul mental autour des identités remarquables
- Clone de 3L11-5
- numéro de l'exo ex : can2C04
- publié le 8/10/2021
(constant) titre
- Source:
- Calcul mental autour des identités remarquables
- Clone de 3L11-5
- numéro de l'exo ex : can2C05
- publié le 10/10/2021
(constant) translationPoint
(constant) translationPolygone
(constant) triangle1longueur2angles
- Source:
Macro de construction d'un triangle à partir d'une longueur et des 2 angles adajcents au côté connu. Le premier point aura pour coordonnées (6,0).
(constant) triangle2longueurs1angle
- Source:
Macro de construction d'un triangle à partir des longueurs des deux côtés d'un angle Le premier point a pour coordonnées (6,0).
(constant) triangle3longueurs
- Source:
Macro de construction d'un triangle à partir de ses 3 dimensions. Le premier point aura pour coordonnées (6,0).
(constant) triangleEquilateral
- Source:
Trace un triangle équilatéral à partir de la donnée de la longueur du côté. Le premier point a pour coordonnées (6;0)
(constant) triangleEquilateral2Sommets
- Source:
Trace un triangle équilatéral à partir de la donnée de 2 points
(constant) triangleRectangle2Cotes
- Source:
Macro de construction d'un triangle rectangle (l'angle droit est le 2e point dans l'ordre du nom) à partir de la donnée de la longueur des deux côtés de l'angle droit. Le premier sommet aura pour coordonnées (6, 0)
(constant) triangleRectangleCoteHypotenuse
- Source:
Macro de construction d'un triangle rectangle (l'angle droit est le 2e point dans l'ordre du nom) à partir de la donnée de la longueur d'un côté et de la longueur de l'hypoténuse. Le premier sommet aura pour coordonnées (6, 0)
versionSimplifiee
- Source:
On donne une relation de proportionnalité du type n objets coûtent x€ et on demande le prix de y objets et le nombre d'objets qu'on peut acheter avec z€.
versionSimplifiee
- Source:
On donne une relation de proportionnalité du type n objets coûtent x€ et on demande le prix de y objets et le nombre d'objets qu'on peut acheter avec z€.
Methods
acos(un)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
un |
number | nombre qui correspond au cosinus de l'angle |
Returns:
flottant : la mesure de l'angle en degrés
affichageUniquementQuestion(i)
- Source:
Affiche uniquement le ieme div de classe question et le div de l'exercice auquel il appartient
Parameters:
Name | Type | Description |
---|---|---|
i |
int |
AfficheCoteSegment()
- Source:
macote=afficheCoteSegment(s,'x',-1,'red',2) affiche une côte sur une flèche rouge d'epaisseur 2 placée 1cm sous le segment s avec le texte 'x' écrit en noir (par defaut) 0,5cm au-dessus (par defaut)
AfficheLongueurSegment()
- Source:
afficheLongueurSegment(A,B) // Note la longueur de [AB] au dessus si A est le point le plus à gauche sinon au dessous
afficheLongueurSegment(A, B, coloropt, dopt) → {AfficheLongueurSegment}
- Source:
Note la longueur de [AB] au dessus si A est le point le plus à gauche sinon au dessous
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut |
d |
number |
<optional> |
0.5
|
Distance entre l'étiquette et le segment. Facultatif, 0.5 par défaut |
Returns:
objet AfficheLongueurSegment
AfficheMesureAngle()
- Source:
afficheMesureAngle(A,B,C) // Affiche la mesure de l'angle ABC arrondie au degré près
afficheMesureAngle(A, B, C, coloropt, distanceopt, labelopt, ecartopt, saillantopt, colorArcopt, rayonopt, fillopt, fillOpaciteopt, arcEpaisseuropt, mesureEnGrasopt) → {object}
- Source:
Affiche la mesure de l'angle ABC arrondie au degré près
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
C |
Point | |||
color |
string |
<optional> |
'black'
|
'black' couleur de la mesure. |
distance |
number |
<optional> |
1.5
|
Taille de l'angle. |
label |
string |
<optional> |
''
|
Si non vide, remplace la mesure de l'angle par ce label. |
ecart |
number |
<optional> |
0.5
|
Distance entre l'arc et sa mesure. |
saillant |
boolean |
<optional> |
true
|
false si on veut l'angle rentrant. |
colorArc |
string |
<optional> |
'black'
|
Couleur de l'arc. |
rayon |
boolean |
<optional> |
false
|
true pour fermer l'angle en vue de colorier l'intérieur. |
fill |
string |
<optional> |
'none'
|
'none' si on ne veut pas de remplissage, sinon une couleur. |
fillOpacite |
number |
<optional> |
0.5
|
Taux d'opacité du remplissage. |
arcEpaisseur |
number |
<optional> |
1
|
épaisseur de l'arc. |
mesureEnGras |
boolean |
<optional> |
false
|
true pour mettre en gras la mesure affichée. |
Returns:
AfficheMesureAngle
- Type
- object
AfficherCrayon(A)
- Source:
Afficher le SVG d'un crayon avec la mine sur le point A
Parameters:
Name | Type | Description |
---|---|---|
A |
point |
afficherTempo(objet, t0opt, topt, ropt)
- Source:
Masque un objet puis l'affiche au bout de t0 s avant de recommencer r fois toutes les t secondes
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
objet |
any | dont l'identifiant est accessible par objet.id |
||
t0 |
number |
<optional> |
1
|
temps en secondes avant l'apparition |
t |
number |
<optional> |
5
|
temps à partir duquel l'animation recommence |
r |
string |
<optional> |
'Infinity'
|
nombre de répétition (infini si ce n'est pas un nombre) |
afficherTempoId(objet, t0opt, topt, ropt)
- Source:
Masque un objet puis l'affiche au bout de t0 s avant de recommencer r fois toutes les t secondes
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
objet |
any | dont l'identifiant est accessible par objet.id |
||
t0 |
number |
<optional> |
1
|
temps en secondes avant l'apparition |
t |
number |
<optional> |
5
|
temps à partir duquel l'animation recommence |
r |
string |
<optional> |
'Infinity'
|
nombre de répétition (infini si ce n'est pas un nombre) |
afficherUnParUn(id)
- Source:
Rend visible un element d'après son id
Parameters:
Name | Type | Description |
---|---|---|
id |
any |
affiniteOrtho()
- Source:
N = affiniteOrtho(M,d,rapport,'N','rgiht')
aireTriangle()
- Source:
aireTriangle(p) retourne l'aire du triangle si p est un triangle, false sinon.
ajouteChampFractionMathLive()
Crée une fraction avec 1 ou 2 champs de réponse et autant de feedbacks. Si seul le numérateur ou le dénominateur sont utilisés pour la fraction, l'autre est précisé. numerateur = false signifie qu'il y a un champ de saisie pour le numérateur. denominateur = 100 signifie que le dénominateur est déjà renseigné à 100. Dans ce cas, on utilise le format Interactif correspondant : 'Num' ou 'Den' Si les deux champs sont à saisir, on utilise deux réponses de formatInteractif 'calcul'.
ajouteChampTexte(exercice, i, param2) → {string}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
exercice |
Exercice | |
i |
number | |
param2 |
* |
Returns:
code HTML du champ texte avec identifiant champTexteEx__Q__ et le span pour le résultat de la question
- Type
- string
ajouteEntier(n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
number |
Returns:
n + la FractionX
ajouteEntier(n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
number |
Returns:
n + la FractionX
ajouterAx(x, lutin)
- Source:
Ajoute x à l'abscisse du lutin
Parameters:
Name | Type | Description |
---|---|---|
x |
number | |
lutin |
Objet |
ajouterAy(y, lutin)
- Source:
Ajoute y à l'ordonnée du lutin
Parameters:
Name | Type | Description |
---|---|---|
y |
number | |
lutin |
Objet |
aleaName(names, n, result) → {Array}
- Source:
Retourne des noms de points (ou des objets) dans un ordre aléatoire.
Example
aleaName() --> 'F'
aleaName(3) --> ['G', 'J', 'K']
aleaName('ABC') --> ['B','A','C']
aleaName(['chat','chien','poisson']) --> ['chien','poisson','chat']
aleaName(['chat','chien','poisson'],2) --> ['poisson','chat']
aleaName([Objet1,Objet2,Objet3]) --> [Objet2,Objet1,Objet3] où Objet peut être un Object, un Array etc.
Parameters:
Name | Type | Description |
---|---|---|
names |
string | Array | // Liste des lettres sous format string ou array |
n |
number | // Nombre de lettres à retourner |
result |
string | Array | // S'il n'y a qu'un seul nom en sortie c'est un string sinon c'est un array |
Returns:
- Type
- Array
aleaVariables(variables, params) → {Object}
- Source:
- See:
Retourne des valeurs aléatoires sous certaines contraintes données. Les calculs se font si possible avec mathjs au format fraction
Example
aleaVariable({a: true}, {valueOf: true}) --> {a: -3} // Génère un entier non nul entre -10 et 10
aleaVariable({a: true, b: true}, {valueOf: true}) --> {a: 5, b: -7}
aleaVariable({a: false, b: false}, {valueOf: true}) --> {a: 4, b: 1} // false => entier entre 1 et 10
aleaVariable({a: true, b: true, test: 'a>b'}, {valueOf: true}) --> {a: 3, b: 1}
aleaVariable({a: true, b: true, test: 'a+b>2'}, {valueOf: true}) --> {a: 10, b: -6}
aleaVariables({a: true}) --> {a: Fraction} // Fraction est un objet de mathjs
Parameters:
Name | Type | Description |
---|---|---|
variables |
Object | // Propriété réservée : test |
params |
Object | // valueOf à true pour avoir les valeurs décimales, format à true pour appliquer texNombre2 // type à 'decimal' et valueOf à true pour obtenir des instances de Decimal() |
Returns:
- Type
- Object
allerA(x, y, lutin)
- Source:
Déplace le lutin de sa position courante à (x;y)
Parameters:
Name | Type | Description |
---|---|---|
x |
number | |
y |
number | |
lutin |
Objet |
angle()
- Source:
angle(A,O,B) renvoie l'angle AOB en degré
angleCodage(A, B, C, options) → {id}
- Source:
Code un angle. L'option codage peut être "simple", "/", "//", "///", "O" "double", "double/", "double//", "double///", "doubleO" "triple", "triple/", "triple//", "triple///", "tripleO" "plein", "plein/", "plein//", "plein///", "pleinO"
Parameters:
Name | Type | Description |
---|---|---|
A |
point | Point sur un côté de l'angle |
B |
point | Sommet de l'angle |
C |
point | Point sur un côté de l'angle |
options |
objet | Défaut : { rayon : 1, couleur: this.couleurCodage, codage: 'plein'} |
Returns:
L'identifiant correspond à l'identifiant des 3 points de l'angle séparés par _
- Type
- id
angleCodageMasquer(A, B, C, options)
- Source:
Masque un codage préalablement créé
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
B |
point | |
C |
point | |
options |
objet | Défaut { tempo: 0 } |
angleCodageMontrer(A, B, C, options)
- Source:
Montre un codage préalablement créé
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
B |
point | |
C |
point | |
options |
objet | Défaut { tempo: 0 } |
angleModulo(a)
- Source:
Convertit un nombre de degrés quelconque en une mesure comprise entre -180 et 180
Parameters:
Name | Type | Description |
---|---|---|
a |
number |
Returns:
angle
angleOriente()
- Source:
Retourne la valeur signée de l'angle AOB en degré.
angleradian()
- Source:
angleradian(A,O,B) renvoie l'angle AOB en radian
angleScratchTo2d(x)
- Source:
Parce que le 0 angulaire de Scratch est dirigé vers le Nord et qu'il croît dans le sens indirect Et que le 0 angulaire de 2d est celui du cercle trigonométrique...
Parameters:
Name | Type | Description |
---|---|---|
x |
number | angle Scratch |
Returns:
angle2d
ApparitionAnimee()
- Source:
apparitionAnimee(objet, dur, pourcentage repeatCount) apparitionAnimee([a,b,c])
dur : durée de l'animation pourcentage : pourcentage de la durée à partir de laquelle les objets sont visibles
appartientDemiDroite()
- Source:
Est-ce que le point C appartien à la demi-droite [AB)] C'est ce que dira cette fonction
appartientDroite()
- Source:
Est-ce que le point C appartien à la droite (AB) C'est ce que dira cette fonction
appartientSegment()
- Source:
Est-ce que le point C appartien au segment [AB] C'est ce que dira cette fonction
Arc(M, Omega, angle, rayon, fill, color, fillOpacite)
- Source:
Parameters:
Name | Type | Default | Description |
---|---|---|---|
M |
object | point de départ de l'arc |
|
Omega |
object | centre de l'arc |
|
angle |
number | compris entre -360 et 360 valeur négative = sens indirect |
|
rayon |
boolean |
false
|
booléen si true, les rayons délimitant l'arc sont ajoutés |
fill |
boolean |
none
|
|
color |
string |
black
|
|
fillOpacite |
number |
0.2
|
// transparence de remplissage de 0 à 1. |
arc(M, Omega, angle, rayon, fill, color, fillOpacite) → {Arc}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
M |
Point | Point de départ de l'arc |
Omega |
Point | Centre de l'arc |
angle |
number | Compris entre -360 et 360. Valeur négative = sens indirect |
rayon |
boolean | Si true, les rayons délimitant l'arc sont ajoutés. Facultatif, false par défaut |
fill |
string | Facultatif, 'none' par défaut |
color |
string | Facultatif, 'black' par défaut |
fillOpacite |
number | Transparence de remplissage de 0 à 1. Facultatif, 0.2 par défaut |
Returns:
Objet Arc
- Type
- Arc
ArcPointPointAngle(M, N, angle, rayon, fill, color, fillOpacite)
- Source:
Parameters:
Name | Type | Default | Description |
---|---|---|---|
M |
Point | //première extrémité de l'arc |
|
N |
Point | //deuxième extrémité de l'arc |
|
angle |
number | //angle au centre de l'arc compris entre -360 et +360 ! |
|
rayon |
boolean |
false
|
//si true, l'arc est fermé par deux rayons aux extrémités |
fill |
string |
none
|
//couleur de remplissage (par défaut 'none'= sans remplissage) |
color |
string |
black
|
//couleur de l'arc |
fillOpacite |
number |
0.2
|
// transparence de remplissage de 0 à 1. |
asin(un)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
un |
number | nombre qui correspond au sinus de l'angle |
Returns:
flottant : la mesure de l'angle en degrés
assignVariables(expression, variables) → {string}
- Source:
Assignation de variables
Parameters:
Name | Type | Description |
---|---|---|
expression |
string | |
variables |
Object |
Returns:
- Type
- string
atan(un)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
un |
number | nombre qui correspond à la tangente de l'angle |
Returns:
flottant : la mesure de l'angle en degrés
attendre()
- Source:
fait "vibrer" le lutin tempo fois autour de sa position courante
avance(d, lutin)
- Source:
Fait avancer le lutin de d unités de lutin dans la direction de son orientation
Parameters:
Name | Type | Description |
---|---|---|
d |
number | |
lutin |
objet |
Axes()
- Source:
axes(xmin,ymin,xmax,ymax,thick,xstep,ystep,epaisseur) // Trace les axes des abscisses et des ordonnées
AxeY(xmin, ymin, xmax, ymax, thick, xstep, ystep, epaisseur, color, ytick, titre)
- Source:
Parameters:
Name | Type | Default | Description |
---|---|---|---|
xmin |
* | ||
ymin |
* | ||
xmax |
* |
30
|
|
ymax |
* |
30
|
|
thick |
* |
0.2
|
|
xstep |
* | ||
ystep |
* | ||
epaisseur |
* | ||
color |
* | ||
ytick |
* | ||
titre |
* |
baisseCrayon(lutin)
- Source:
Fait entrer le lutin dans le mode "trace"
Parameters:
Name | Type | Description |
---|---|---|
lutin |
objet |
barycentre(p)
- Source:
P = barycentre(p,'P','below') Crée le point P barycentre du polygone p, son nom 'P' sera placé sous le point si il est tracé et labelisé.
Parameters:
Name | Type | Description |
---|---|---|
p |
Polygone |
bissectrice()
- Source:
d = bissectrice(A,O,B) // Bissectrice de l'angle AOB d = bissectrice(A,O,B,'blue') // Bissectrice de l'angle AOB en bleu
cacherParDiv(id)
- Source:
Rend invisible un element d'après son id
Parameters:
Name | Type | Description |
---|---|---|
id |
string |
cacherTempo(objet, t0opt, topt, ropt)
- Source:
Masque un objet puis l'affiche au bout de t0 s avant de recommencer r fois toutes les t secondes
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
objet |
any | dont l'identifiant est accessible par objet.id |
||
t0 |
number |
<optional> |
1
|
temps en secondes avant l'apparition |
t |
number |
<optional> |
5
|
temps à partir duquel l'animation recommence |
r |
string |
<optional> |
'Infinity'
|
nombre de répétition (infini si ce n'est pas un nombre) |
calcule()
- Source:
retourne un décimal sans décimales bizarres
calculer(expression, params)
- Source:
Retourne toutes les étapes de calculs d'une expression numérique ou de développement-réduction d'une expression littérale
Parameters:
Name | Type | Description |
---|---|---|
expression |
string | // Une expression à calculer ou à développer |
params |
Objet | // Les paramètres (commentaires visibles , sous-étapes visibles, fraction-solution au format MixedNumber) |
calculeS()
- Source:
retourne une chaine contenant le résultat du calcul avec la virgule comme séparateur et pas de décimales bizarres
carre(A, B, color)
- Source:
Trace en 'color' le carré direct qui a pour côté [AB].
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
color |
string | facultatif |
carreIndirect()
- Source:
carreIndirect(A,B) //Trace le carré indirect qui a pour côté [AB]
centreCercleCirconscrit(A, B, C, color)
- Source:
Centre du cercle circonscrit au triangle ABC
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
C |
Point | |
color |
string |
centreGraviteTriangle(A, B, C, color)
- Source:
Centre de gravité du triangle ABC
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
C |
Point | |
color |
string |
Cercle()
- Source:
c = cercle(O,r) //Cercle de centre O et de rayon r
cercle(O, r, coloropt) → {Cercle}
- Source:
Construit le cercle de centre O, de rayon r et de couleur color
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
O |
Point | Centre du cercle |
||
r |
number | Rayon du cercle |
||
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut. |
Returns:
objet Cercle
- Type
- Cercle
cercle3d()
- Source:
LE CERCLE
CercleCentrePoint()
- Source:
c = cercleCentrePoint(O,A) //Cercle de centre O passant par A c = cercleCentrePoint(O,A,'blue') //Cercle de centre O passant par A en bleu
choisiDelta()
- Source:
delta(true) retourne dans un tableau des valeurs de a, b, c telles que bb-4ac >0 delta(false) retourne dans un tableau des valeurs de a, b, c telles que bb-4ac <0
cibleCarree(x, y, rang, num, taille, color, opacite, param0)
- Source:
création d'une cible carrée pour l'auto-correction
Parameters:
Name | Type | Description |
---|---|---|
x |
number | |
y |
number | // les coordonnées du point au centre de la cible |
rang |
number | // le nombre de cases de large |
num |
number | // Un numéro ou rien pour identifier la cible (quand il y en a plusieurs) |
taille |
number | // en cm, la taille des cases |
color |
string | // la couleur de la cible |
opacite |
number | // l'opacité de la cible |
param0 |
CibleCouronne()
- Source:
création d'une cible couronne en forme de rapporteur ou semi-rapporteur pour l'auto-correction
cibleCouronne(taille, taille2, depart, nbDivisions, nbSubDivisions, semi, label, color, opacite)
- Source:
création d'une cible couronne en forme de rapporteur ou semi-rapporteur pour l'auto-correction
Parameters:
Name | Type | Description |
---|---|---|
taille |
number | distance entre le centre de la cible et l'arc intérieur |
taille2 |
number | distance entre l'arc intérieur et l'arc extérieur de la couronne |
depart |
number | angle pour démarrer la numérotation des zones 0 = est |
nbDivisions |
number | nombre de secteurs dans la couronne ou la semi-couronne |
nbSubDivisions |
number | nombre de graduations à l'intérieur de chaque zone pour un repérage plus précis |
semi |
boolean | si true alors seulement 180° sinon couronne à 360° |
label |
boolean | si true alors des lettres sont ajoutées pour identifier les zones |
color |
string | La couleur de la cible |
opacite |
number | son opacité. |
cibleRonde(x, y, rang, num, taille, color, opacite, param0)
- Source:
création d'une cible ronde pour l'auto-correction
Parameters:
Name | Type | Description |
---|---|---|
x |
number | |
y |
number | // les coordonnées du point en bas à gauche de la cible |
rang |
number | // le nombre de cases de large |
num |
number | // Un numéro ou rien pour identifier la cible (quand il y en a plusieurs) |
taille |
number | // en cm, la taille des cases |
color |
string | // la couleur de la cible |
opacite |
number | // l'opacité de la cible |
param0 |
clone(originalObject)
- Source:
fork de https://javascript.developpez.com/actu/94357/JavaScript-moins-Realiser-une-copie-parfaite-d-objet/ Ne fonctionne pas complètement : ne copie pas les méthodes svg et tikz...
Parameters:
Name | Type | Description |
---|---|---|
originalObject |
ObjetMathalea2D |
Returns:
copie de cet objet.
CodageAngleDroit()
- Source:
codageAngleDroit(A,O,B) //Fait un codage d'angle droit de 4 mm pour l'angle direct AOB codageAngleDroit(A,O,B,.5) //Fait un codage d'angle droit de 5 mm pour l'angle direct AOB
codageAngleDroit(A, O, B, coloropt, dopt, epaisseur, opacity, fill, fillopacity) → {CodageAngleDroit}
- Source:
Fait un codage d'angle droit pour l'angle direct AOB.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
O |
Point | |||
B |
Point | |||
color |
string |
<optional> |
'black'
|
|
d |
number |
<optional> |
0.4
|
Taille de l'angle droit en cm. |
epaisseur |
number | épaisseur du trait |
||
opacity |
number | opacité du trait |
||
fill |
string | couleur de remplissage |
||
fillopacity |
number | opacité de remplissage |
Returns:
CodageAngleDroit
- Type
- CodageAngleDroit
codageAngleDroit(A, B, C, options) → {array}
- Source:
Trace le petit carré au crayon
Parameters:
Name | Type | Description |
---|---|---|
A |
point | Point sur un côté de l'angle |
B |
point | Sommet de l'angle |
C |
point | Point sur un côté de l'angle |
options |
objet | Défaut : {longueur : 0.3, couleur: this.couleurCodage} |
Returns:
[idTrait1, idTrait2]
- Type
- array
codageAngleDroitMasquer(id, options)
- Source:
Masque le codage d'un angle droit
Parameters:
Name | Type | Description |
---|---|---|
id |
int | Identifiant du codage d'un angle droit |
options |
objet | Défaut { tempo: 0 } |
CodageBissectrice()
- Source:
m = codagebissectrice(A,O,B) ajoute des arcs marqués de part et d'autres de la bissectrice mais ne trace pas celle-ci.
CodageMediatrice()
- Source:
m = codageMediatrice(A,B,'blue','×') // Ajoute le codage du milieu et de l'angle droit pour la médiatrice de [AB] en bleu
CodageMilieu()
- Source:
c=codageMilieu(A,B,'red','||',false) marque les deux moitiés du segment [AB] avec || en rouge, le milieu n'est pas tracé car dernier argument à false. m=codageMilieu(C,D) marque l'emplacement du milieu de [CD] et marque avec X les deux moitiés.
codageMilieu(A, B, coloropt, markopt, milopt)
- Source:
Marque les deux moitiés du segment [AB] avec mark en color en traçant éventuellement le milieu
Example
codageMilieu(A,B,'red','||',false) marque les deux moitiés du segment [AB] avec || en rouge, le milieu n'est pas tracé car dernier argument à false.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
color |
string |
<optional> |
'black'
|
Couleur du codage. Facultatif, 'black' par défaut |
mark |
string |
<optional> |
'x'
|
Peut être '||' ou 'x'. Facultatif, 'x' par défaut |
mil |
boolean |
<optional> |
true
|
Trace ou nom le point du milieu. Facultatif, true par défaut |
Returns:
CodageMilieu
CodeAngle()
- Source:
m=codeAngle(A,O,45,'X','black',2,1,'red',0.4) code un angle du point A dont le sommet est O et la mesure 45° (sens direct) avec une marque en X. la ligne est noire a une épaisseur de 2 une opacité de 100% et le remplissage à 40% d'opacité est rouge.
codeAngle(debut, centre, angle, tailleopt, markopt, coloropt, epaisseuropt, opaciteopt, fillopt, fillOpaciteopt, mesureOnopt, noAngleDroitopt, texteACoteopt, tailleTexteopt)
- Source:
Example
codeAngle(A,O,45,0.8,'X','black',2,1,'red',0.4) // code un angle à partir du point A dont le sommet est O et la mesure 45° (sens direct) avec une marque en X. La ligne est noire a une épaisseur de 2 une opacité de 100% et le remplissage à 40% d'opacité est rouge.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
debut |
Point | |||
centre |
Point | |||
angle |
number | |||
taille |
number |
<optional> |
0.8
|
Facultatif. 0.8 par défaut. |
mark |
string |
<optional> |
''
|
Facultatif. Vide par défaut. |
color |
string |
<optional> |
'black'
|
Facultatif. 'black' par défaut. |
epaisseur |
number |
<optional> |
1
|
Facultatif. 1 par défaut. |
opacite |
number |
<optional> |
1
|
Facultatif. 1 par défaut. |
fill |
string |
<optional> |
'none'
|
Facultatif. 'none' par défaut |
fillOpacite |
number |
<optional> |
0.2
|
Facultatif. 0.2 par défaut |
mesureOn |
boolean |
<optional> |
false
|
Facultatif. false par défaut |
noAngleDroit |
boolean |
<optional> |
false
|
Pour choisir si on veut que l'angle droit soit marqué par un carré (from EE) |
texteACote |
string |
<optional> |
''
|
Pour mettre un texte à côté de l'angle (from EE) : encore optimisable |
tailleTexte |
number |
<optional> |
1
|
Pour choisir la taille du texte à côté de l'angle (from EE) |
Returns:
CodeAngle
CodeSegment(A, B, markopt, coloropt)
- Source:
codeSegment(A,B,'×','blue') // Code le segment [AB] avec une croix bleue.
Attention le premier argument ne peut pas être un segment
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Première extrémité du segment |
||
B |
Point | Seconde extrémité du segment |
||
mark |
string |
<optional> |
'||'
|
Symbole posé sur le segment |
color |
string |
<optional> |
'black'
|
Couleur du symbole |
CodeSegments(mark, color, …args)
- Source:
codeSegments('×','blue',A,B, B,C, C,D) // Code les segments [AB], [BC] et [CD] avec une croix bleue
codeSegments('×','blue',[A,B,C,D]) // Code les segments [AB], [BC], [CD] et [DA] (attention, chemin fermé, pratique pour des polygones pas pour des lignes brisées)
codeSegments('×','blue',s1,s2,s3) // Code les segments s1, s2 et s3 avec une croix bleue
codeSegments('×','blue',p.listePoints) // Code tous les segments du polygone avec une croix bleue
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
mark |
string |
||
|
Symbole posé sur le segment |
|
color |
string |
black
|
Couleur du symbole |
|
args |
any |
<repeatable> |
Les segments différement codés. Voir exemples. |
codeTikz()
- Source:
codeTikz(segment(A,B),polygone(D,E,F),labelPoints(A,B))
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora avec aide EE et JCL Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Description didactique de l'exercice Gilles Mora Référence
compareNombres()
- Source:
Aléatoirisation du sujet 2022 de CAN 6e Gilles Mora Référence can6a-2022
compasCercleCentrePoint(centre, point, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
centre |
point | |
point |
point | Point de départ du tracé du cercle |
options |
objet | Défaut : { tempo: this.tempo, sens: this.vitesse / 2, epaisseur: this.epaisseur, couleur: this.couleurCompas, pointilles: this.pointilles } |
compasCoucher(options)
- Source:
Voir le compas en vue de dessus avant qu'il trace un arc de cercle
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo } |
compasDeplacer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
compasEcarter(longueur, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
longueur |
int | écartement en cm |
options |
objet | Défaut : { tempo: this.tempo, vitesse: this.vitesse } |
compasEcarter2Points(A, B, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | Pointe du compas |
B |
point | Mine du compas |
options |
objet | Défaut : { tempo: this.tempo, vitesse: this.vitesse, sens : this.vitesse / 2 } |
compasEcarterAvecRegle(longueur, options)
- Source:
Fais apparaitre la règle à l'horizontale, met le compas vertical et écarte le compas le long de la règle pour lire son écartement
Parameters:
Name | Type | Description |
---|---|---|
longueur |
int | |
options |
* | Défaut : { tempo: this.tempo, vitesse: this.vitesse, sens : this.vitesse / 2 } |
compasLever(options)
- Source:
Remettre le compas en position standard. Son état est sauvegardé dans le booléen this.compas.leve.
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo } |
compasMasquer(options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
options |
objet |
compasMontrer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
compasRetourner(options)
- Source:
Change l'orientation du compas. Par défaut, elle est vers la droite. L'orientation courante du compas est sauvegardée dans this.compas.orientation
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo} |
compasRotation(angle, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
angle |
int | |
options |
objet |
compasTracerArc2Angles(angle1, angle2, options) → {id}
- Source:
Trace un arc de cercle en gardant l'écartement et le centre actuel. L'angle de départ sera choisi pour être le plus proche de l'angle actuel
Parameters:
Name | Type | Description |
---|---|---|
angle1 |
int | |
angle2 |
int | |
options |
objet | Défaut : { tempo: this.tempo, sens: this.vitesse / 2, epaisseur: this.epaisseur, couleur: this.couleurCompas, pointilles: this.pointilles } |
Returns:
- Type
- id
compasTracerArcCentrePoint(centre, point, options) → {id}
- Source:
Trace un arc de cercle autour d'un point. La longueur de l'arc est déterminée par l'option delta en degré qui est ajoutée de part et d'autre du point
Parameters:
Name | Type | Description |
---|---|---|
centre |
point | |
point |
point | |
options |
objet | Défaut : { delta: 10, tempo: this.tempo, sens: this.vitesse / 2, epaisseur: this.epaisseur, couleur: this.couleurCompas, pointilles: this.pointilles } |
Returns:
- Type
- id
compasZoom(pourcentage, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
pourcentage |
int | 200 pour doubler la taille |
options |
objet | tempo = 0 par défaut |
Cone3d()
- Source:
LE CONE
ConstructionBissectrice()
- Source:
m = constructionBissectrice(A,O,B,false,'blue','×',tailleLosange,couleurBissectrice,epaisseurBissectrice) // Trace et code la bissectrice en laissant apparent les traits de construction au compas
ConstructionMediatrice()
- Source:
m = constructionMediatrice(A,B,false,'blue','×') // Trace et code la médiatrice en laissant apparent les traits de construction au compas
cos(a)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
a |
number | angle en degrés |
Returns:
flottant : le cosinus de l'angle
cosineInterpolate()
- Source:
Courbe()
- Source:
courbe(f,xmin,xmax,color,epaisseur,repere,step) // Trace la courbe de f
Courbe2()
- Source:
courbe2(f,{repere,color,epaisseur,step,xMin,xMax,yMin,yMax,xUnite,yUnite}) // Trace la courbe de f
courbeInterpolee(tableau, couleur, epaisseur, repere, xmin, xmax)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
tableau |
array | de coordonnées [x,y] |
couleur |
string | |
epaisseur |
number | |
repere |
objet | (ou tableau [xscale,yscale]) |
xmin |
number | |
xmax |
number |
courbeInterpolee2(tableau, couleur, epaisseur, repere, xmin, xmax)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
tableau |
array | de coordonnées [x,y] |
couleur |
string | |
epaisseur |
number | |
repere |
objet | (ou tableau [xscale,yscale]) |
xmin |
number | |
xmax |
number |
CourbeSpline()
- Source:
crée un objet correspondant au tracé de la fonction f de la classe Spline f devra être définie avant...
crayonDeplacer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
crayonMasquer(options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
options |
objet |
crayonMontrer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
crayonRotation(angle, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
angle |
int | |
options |
objet |
creeIdPourComparaison()
- Source:
tableau_url_tex est un tableau de tableaux
Chaque tableau est de la forme [nom du répertoire,nom du fichier, nom du fichier de la correction]
On ajoute un dernnier element qui est une simplification du nom du répertoire (pas de points, pas /items)
creerLutin(…args)
- Source:
Crée une nouvelle instance de l'objet lutin
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
args |
any |
<repeatable> |
En fait, il n'y a pas d'argument... il faudra les renseigner après la création de l'objet. Voire l'objet lutin pour la liste de ses attributs (lutin.x, lutin.y, lutin.orientation, ...) |
Returns:
Instance d'un lutin
Cylindre3d(centrebase1, centrebase2, normal, rayon1, rayon2)
- Source:
LE CYLINDRE
Parameters:
Name | Type | Description |
---|---|---|
centrebase1 |
Point3d | |
centrebase2 |
Point3d | |
normal |
Vecteur3d | |
rayon1 |
Vecteur3d | |
rayon2 |
Vecteur3d |
dansLaCibleCarree()
- Source:
retourne un couple de coordonnées correspondant au centre d'une cible afin que le point (x,y) se trouve dans la case correspondante à cellule cellule est une chaine comme 'A1' ou 'B3'
dansLaCibleRonde()
- Source:
Comme dansLaCibleCarree mais pour un cible ronde. (voir ci-dessus) Cellule va de A1 à Hn où n est le rang de la cible. taille c'est la différence entre deux rayons successifs. x et y sont les coordonnées du point à cibler.
degres()
- Source:
Convertit un angle de radian vers degrés et fonction inverse
Example
// PI->180
demicercle3d()
- Source:
LE DEMI-CERCLE
demiDroite(A, B, coloropt)
- Source:
Trace la demi-droite d'origine A passant par B et de couleur color
Example
demiDroite(A,B,'blue') // Demi-droite d'origine A passant par B et de couleur bleue
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut |
demiDroiteAvecExtremite(A, B, coloropt)
- Source:
Trace la demi-droite d'origine A passant par B avec l'origine marquée
Example
demiDroite(A,B,'blue') // Demi-droite d'origine A passant par B et de couleur bleue
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut |
deplaceLabel()
- Source:
deplaceLabel(p1,'AB','below') // Si il y a un point nommé 'A' ou 'B' dans le polygone son nom sera mis en dessous du point
deplacer(objet, A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
objet |
string | 'regle', 'equerre', 'requerre, 'compas', 'rapporteur' ou 'crayon' |
A |
point | |
options |
objet |
dessousDessus(d, A)
- Source:
fonction qui analyse si le point A est au-dessus ou en dessous de la droite d retourne 'sur', 'dessus', 'dessous' ou 'gauche' ou 'droite" si la droite est verticale.
Parameters:
Name | Type | Description |
---|---|---|
d |
droite | |
A |
point |
differenceFraction(f)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f |
FractionX | Fraction |
Returns:
la fractionX - f résultat simplifié
differenceFraction(f)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f |
FractionX | Fraction |
Returns:
la fractionX - f résultat simplifié
distancePointDroite(A, d) → {number}
- Source:
Calcule la distance entre un point et une droite. 1ere version utilisant la projection orthogonale 2eme version utilisant la symétrie axiale (abandonnée)
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
d |
Droite |
Returns:
longueur
- Type
- number
diviseEntier(n) → {Fraction}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
number | entier divisé par la fraction |
Returns:
n divisé par fraction
- Type
- Fraction
diviseEntier(n) → {Fraction}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
number | entier divisé par la fraction |
Returns:
n divisé par fraction
- Type
- Fraction
diviseFraction(f2) → {Fraction}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
Fraction |
Returns:
f/f2
- Type
- Fraction
diviseFraction(f2) → {Fraction}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
Fraction |
Returns:
f/f2
- Type
- Fraction
Droite()
- Source:
d = droite(A,B) // La droite passant par A et B d = droite(A,B,'(d)') // La droite passant par A et B se nommant (d) d = droite(a,b,c,'(d)') // La droite définie par les coefficients de ax +by + c=0 (équation de la droite (a,b)!==(0,0)) d = droite(A,B,'(d)','blue') //La droite passant par A et B se nommant (d) et de couleur bleue
droite(…args, nom, color) → {Droite}
- Source:
Examples
droite(A,B,'(d)') // La droite passant par A et B se nommant (d)
droite(a,b,c,'(d)') // La droite définie par les coefficients de ax +by + c = 0 (équation de la droite (a,b)!==(0,0))
droite(A,B,'(d)','blue') // La droite passant par A et B se nommant (d) et de couleur bleue
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
args |
any |
<repeatable> |
Deux points ou les coefficients a, b, c de ax + by + c = 0 où (a,b) !== (0,0) |
nom |
string | Facultatif |
|
color |
string | Facultatif |
Returns:
Droite
- Type
- Droite
DroiteGraduee(xopt, yopt, positionopt, typeopt, longueurUniteopt, divisionopt, longueurTotaleopt, originopt, uniteopt, labelGaucheopt, labelUniteopt, gradue, …args)
- Source:
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
x |
number |
<optional> |
0
|
Place le début en (x,y). |
y |
number |
<optional> |
0
|
|
position |
string |
<optional> |
'H'
|
pour horizontale 'V' pour verticale |
type |
string |
<optional> |
'dd'
|
pour demi-droite 'd' ou n'importe quoi pour droite |
longueurUnite |
number |
<optional> |
10
|
longueur en cm de la taille d import { ObjetMathalea2D } from '/modules/mathalea2d.js'; |
division |
number |
<optional> |
10
|
nombre de parts à faire entre deux grosses graduations |
longueurTotale |
number |
<optional> |
15
|
longueur totale en cm utilisable |
origin |
number |
<optional> |
0
|
valeur de la première graduation |
unite |
number |
<optional> |
1
|
valeur de la deuxième graduation |
labelGauche |
string |
<optional> |
'O'
|
Ce qu'on écrit sous la première graduation |
labelUnite |
string |
<optional> |
'I'
|
Ce qu'on écrit sous la deuxième graduation |
gradue |
boolean |
true
|
Si true, alors les grosses graduation à partir de la troisième auront l'abscisse renseignée |
|
args |
any |
<repeatable> |
des points à placer au format ['M',xM] |
DroiteGraduee2()
- Source:
droiteHorizontaleParPoint()
- Source:
d = droiteHorizontaleParPoint(A,'d1',red') // Trace en rouge la droite horizontale passant par A
droiteParPointEtParallele(A, d, nomopt, coloropt) → {Droite}
- Source:
Trace en color la droite nom parallèle à d passant par A
Example
droiteParPointEtParallele(A,d,'d1',red') // Trace en rouge la droite d1 parallèle à la droite d passant par A
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
d |
Droite | |||
nom |
string |
<optional> |
''
|
Facultatif, vide par défaut |
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut |
Returns:
- Type
- Droite
droiteParPointEtPente()
- Source:
d = droiteParPointEtPente(A,p,'d1',red') //Droite passant par A, de pente p et de couleur rouge
droiteParPointEtPerpendiculaire()
- Source:
d = droiteParPointEtPerpendiculaire(A,d,'d1',red') // Trace en rouge la perpendiculaire à la droite (d) passant par A
droiteParPointEtVecteur()
- Source:
d = droiteParPointEtVecteur(A,v,'d1',red') //Droite passant par A, de vecteur directeur v et de couleur rouge
droiteVerticaleParPoint()
- Source:
d = droiteVerticaleParPoint(A,'d1',red') // Trace en rouge la droite verticale passant par A
ecritureParentheseSiNegatif()
- Source:
Description didactique de l'exercice
ecritureParentheseSiNegatif()
- Source:
Modèle d'exercice très simple pour la course aux nombres
elimineDoublons()
prend un tableau de propositions [{texte: 'prop1', statut: true, feedback: 'Correct !'}, {texte: 'prop2', statut: false, ....} élimine en cas de doublon la proposition fausse ou la deuxième proposition si elle sont toutes les deux fausses.
Ellipse()
- Source:
c = ellipse(O,rx,ry) //Ellipse de centre O et de rayon rx et ry
entierDivise(n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
coefficient |
Returns:
La FractionX divisée par n (denominateur n fois plus grand)
entierDivise(n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
coefficient |
Returns:
La FractionX divisée par n (denominateur n fois plus grand)
entierMoinsFraction(n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
number |
Returns:
n - la FractionX
entierMoinsFraction(n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
number |
Returns:
n - la FractionX
equerreDeplacer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
equerreMasquer(options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
options |
objet |
equerreMontrer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
equerreRotation(angle, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
angle |
int | |
options |
objet |
equerreZoom(pourcentage, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
pourcentage |
int | 200 pour doubler la taille |
options |
objet | tempo = 0 par défaut |
estDansQuadrilatere(M)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
M |
estDansTriangle(M)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
M |
estSurDroite(A, d)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
d |
droite |
Returns:
true si A appartient à d
estUneSimplification(f2)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX |
Returns:
true si f2 = f et f2 est plus réduite que f
estUneSimplification(f2)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX |
Returns:
true si f2 = f et f2 est plus réduite que f
exerciceCustom(exercice)
- Source:
Lorsque l'évènement 'exercicesAffiches' est lancé par mathalea.js on vérifie la présence du bouton de validation d'id btnValidationEx{i} créé par listeQuestionsToContenu et on y ajoute un listenner pour vérifier les réponses cochées
Parameters:
Name | Type | Description |
---|---|---|
exercice |
object |
exerciceListeDeroulante(exercice)
Lorsque l'évènement 'exercicesAffiches' est lancé par mathalea.js on vérifie la présence du bouton de validation d'id btnValidationEx{i} créé par listeQuestionsToContenu et on y ajoute un listenner pour vérifier les réponses cochées
Parameters:
Name | Type | Description |
---|---|---|
exercice |
object |
exerciceMathLive(exercice)
Lorsque l'évènement 'exercicesAffiches' est lancé par mathalea.js on vérifie la présence du bouton de validation d'id btnValidationEx{i} créé par listeQuestionsToContenu et on y ajoute un listenner pour vérifier les réponses saisies dans les math-field
Parameters:
Name | Type | Description |
---|---|---|
exercice |
object |
exerciceNonInteractif(exercice)
- Source:
Lorsque l'évènement 'exercicesAffiches' est lancé par mathalea.js on vérifie la présence du bouton de validation d'id btnValidationEx{i} créé par listeQuestionsToContenu et on y ajoute un listenner pour vérifier les réponses saisies dans les math-field Si le bouton n'existe pas on le crée
Parameters:
Name | Type | Description |
---|---|---|
exercice |
object |
exerciceQcm(exercice)
Lorsque l'évènement 'exercicesAffiches' est lancé par mathalea.js on vérifie la présence du bouton de validation d'id btnValidationEx{i} créé par listeQuestionsToContenu et on y ajoute un listenner pour vérifier les réponses cochées
Parameters:
Name | Type | Description |
---|---|---|
exercice |
object |
expTrinome(a, b, c) → {string}
- Source:
onction qui retourne un polynome du second degré correctement écrit.
Parameters:
Name | Type | Description |
---|---|---|
a |
number | |
b |
number | |
c |
number |
Returns:
- Type
- string
fixeBordures(rxmin, rxmax, rymin, rymax, rzoom, objets) → {object}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
rxmin |
number | marge à gauche 0.5 par défaut (peut être fixée à 0 si on veut) |
rxmax |
number | marge à droite 0.5 par défaut |
rymin |
number | marge en bas 0.5 par défaut (peut être fixée à 0 si on veut) |
rymax |
number | marge en haut 0.5 par défaut |
rzoom |
number | facteur multiplicatif des marges... implémenté en cas de problème avec le zoom ? |
objets |
object | // tableau contenant les objets à afficher Les objets affichables doivent avoir un attribut this.bordures = [xmin, ymin, xmax, ymax] 4 nombres dans cet ordre. Si this.bordures n'est pas défini ou n'est pas un tableau de 4 éléments, l'objet est ignoré Si aucun objet passé en argument n'a de "bordures" alors la fonction retourne une zone inaffichable et un message d'erreur est créé |
Returns:
{xmin, ymin, xmax, ymax}
- Type
- object
FondEcran(url, x, y, largeur, hauteur)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
url |
url | de l'image |
x |
number | tous ces nombres sont en pixels |
y |
number | Attention à l'orientation de l'axe SVG |
largeur |
number | |
hauteur |
number |
fractionDecimale()
- Source:
Returns:
NaN si la FractionX n'est pas un nombre décimal sinon retourne une FractionX avec la bonne puissance de 10 au dénominateur
fractionDecimale()
- Source:
Returns:
NaN si la FractionX n'est pas un nombre décimal sinon retourne une FractionX avec la bonne puissance de 10 au dénominateur
FractionParPosition()
- Source:
Fonction dépréciée depuis que latexParCoordonnees() est au point. x,y sont les coordonnées du début du trait de fraction, 0;0 par défaut num et den sont les numérateurs et dénominateurs (1 et 2) par défaut On peut changer la couleur (noir par défaut) permet d'afficher une fraction à une position donnée en SVG et Latex Les nombres ne sont pas en mode Maths
getDureeFromUrl() → {string}
- Source:
Returns:
Vue depuis l'URL
- Type
- string
getFilterFromUrl() → {string}
- Source:
Returns:
Filtre depuis l'URL
- Type
- string
getLogFromUrl() → {string}
- Source:
Returns:
Log nécessaire depuis l'URL
- Type
- string
getUrlSearch() → {string}
- Source:
Récupère l'URL et s'assure que la vue et le userId sont notés Essai de debug
Returns:
l'url vérifiée réécrite
- Type
- string
getUrlSearchOld() → {string}
- Source:
Récupère l'URL et s'assure que la vue et le userId sont notés
Returns:
l'url vérifiée
- Type
- string
getUserId() → {string}
- Source:
Returns:
userId depuis l'URL, context ou sessionStorage, le stocke dans sessionStorage et le renvoie
- Type
- string
getUserIdFromUrl() → {string}
- Source:
Returns:
userId depuis l'URL
- Type
- string
getVueFromUrl() → {string}
- Source:
Returns:
Vue depuis l'URL
- Type
- string
getZoomFromUrl() → {string}
- Source:
Returns:
Vue depuis l'URL
- Type
- string
goTabVue()
- Source:
Met à jour l'URL avec la vue et le userId s'ils sont connus et go
graphiqueInterpole()
- Source:
Grille()
- Source:
grille(xmin,ymin,xmax,ymax,color,opacite,pas) // Trace les axes des abscisses et des ordonnées
grille()
- Source:
grille(xmin,ymin,xmax,ymax,color,opacite,pas) // Trace les axes des abscisses et des ordonnées
GrilleHorizontale()
- Source:
grilleHorizontale(xmin,ymin,xmax,ymax,color,opacite,pas) // Trace les parallèle à l'axe des ordonnées
grilleHorizontale()
- Source:
grilleHorizontale(xmin,ymin,xmax,ymax,color,opacite,pas) // Trace les axes des abscisses et des ordinnées
grilleVerticale()
- Source:
grilleVerticale(xmin,ymin,xmax,ymax,color,opacite,pas)
hauteurTriangle(A, B, C, color)
- Source:
Hauteur issue de A relative à [BC]
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
C |
Point | |
color |
string |
homothetie(A, O, k, nomopt, positionLabelopt)
- Source:
M = homothetie(A,O,k) //M est l'image de A dans l'homothétie de centre O et de rapport k
M = homothetie(A,O,k,'M') //M est l'image de A dans l'homothétie de centre O et de rapport k et se nomme M
M = homothetie(A,O,k,'M') //M est l'image de A dans l'homothétie de centre O et de rapport k, se nomme M et le nom est en dessous du point
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
point | Point-antécédent de l'homothétie |
||
O |
point | Centre de l'homothétie |
||
k |
number | Rapport de l'homothétie |
||
nom |
string |
<optional> |
''
|
Nom du point-image |
positionLabel |
position |
<optional> |
'above'
|
Position du point-image |
homothetie3d()
- Source:
L'homothetie
HomothetieAnimee()
- Source:
homothetieAnimee(s,O,k) //Animation de la homothetie de centre O et de rapport k pour s homothetieAnimee([a,b,c],O,k) //Animation de la homothetie de centre O et de rapport k pour les objets a, b et v
html(numeroExercice, i)
- Source:
Renvoie le code HTML de l'animation
Parameters:
Name | Type | Description |
---|---|---|
numeroExercice |
int | Numéro de l'exercice |
i |
int | Numéro de la question |
htmlBouton(numeroExercice, i)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
numeroExercice |
int | Numéro de l'exercice |
i |
int | Numéro de la question |
Returns:
Code HTML avec le bouton qui affiche ou masque un div avec l'animation
image(url) → {id}
- Source:
Affiche une image (donnée par son URL) au point A
Parameters:
Name | Type | Description |
---|---|---|
url |
string |
Returns:
- Type
- id
inferieurlarge(f2) → {boolean}
- Source:
Retourne true si la fraction courante est inférieure ou égale à f2
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
- Type
- boolean
inferieurlarge(f2) → {boolean}
- Source:
Retourne true si la fraction courante est inférieure ou égale à f2
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
- Type
- boolean
inferieurstrict(f2) → {boolean}
- Source:
Retourne true si la fraction courante est strictement inférieure à f2
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
- Type
- boolean
inferieurstrict(f2) → {boolean}
- Source:
Retourne true si la fraction courante est strictement inférieure à f2
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
- Type
- boolean
Integrale()
- Source:
Integrale(f,{repere,color,epaisseur,step,a,b,opacite,hachures}) // Trace la courbe de f a et b sont les bornes (dans l'ordre croissant a<b) opacite = 0.5 par défaut hachures = 0 par défaut (= 'northeastlines')
inverse()
- Source:
Returns:
l'inverse de la fraction
inverse()
- Source:
Returns:
l'inverse de la fraction
isArrayInArray(arr, item) → {boolean}
- Source:
Vérifie la présence d'un tableau dans un tableau de tableau
Parameters:
Name | Type | Description |
---|---|---|
arr |
array | |
item |
array |
Returns:
- Type
- boolean
isContentSymbolNode(node) → {boolean}
- Source:
Find if there is a SymbolNode in the node
Parameters:
Name | Type | Description |
---|---|---|
node |
Mathnode |
Returns:
- Type
- boolean
isDecimal(x) → {boolean}
- Source:
Check if x is a decimal number
Parameters:
Name | Type | Description |
---|---|---|
x |
Object | // Object type = Fraction (mathjs) |
Returns:
- Type
- boolean
isEqual(f)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f |
FractionX | Fraction |
Returns:
true si la FractionX est égale à la fraction passée en argument.
isEqual(f)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f |
FractionX | Fraction |
Returns:
true si la FractionX est égale à la fraction passée en argument.
isUserIdOk(exercice, nbBonnesReponses, nbMauvaisesReponses)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
exercice |
object | |
nbBonnesReponses |
number | |
nbMauvaisesReponses |
number |
item_to_contenu()
- Source:
Met à jour le code LaTeX à partir de l'identifiant d'un exercice.
On regarde d'abord si un exercice aléatoire a le même identifiant.
//// ANNULÉ //// Si ce n'est pas le cas, on cherche dans le répertoire /items s'il y a un répertoire qui correspond
LabelLatexPoint()
- Source:
labelPoint(A,B) pour nommer les points A et B Le nombre d'arguments n'est pas limité A utiliser par exemple si le label est A_1
labelLatexPoint(points:) → {LabelLatexPoint}
- Source:
Nomme les points passés en argument, le nombre d'arguments n'est pas limité.
Parameters:
Name | Type | Description |
---|---|---|
points: |
objext | un tableau des points dont on veut afficher les labels color: leur couleur taille: la taille du texte (voir latexParCoordonnees) largeur: la largeur en pixels du label (par défaut 10) a des fins de centrage hauteur: la hauteur en pixels du label à des fins de centrage background: transparent si '' sinon une couleur |
Returns:
LabelLatexPoint
- Type
- LabelLatexPoint
LabelPoint()
- Source:
labelPoint(A,B) pour nommer les points A et B Le nombre d'arguments n'est pas limité
labelPoint(…args) → {LabelPoint}
- Source:
Nomme les points passés en argument, le nombre d'arguments n'est pas limité.
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
args |
any |
<repeatable> |
Points |
Returns:
LabelPoint
- Type
- LabelPoint
labelX()
- Source:
labelX(xmin,xmax,step,color,pos,coeff) // Place des graduations
LabelY()
- Source:
labelY(ymin,ymax,step,color,pos,coeff) // Place des graduations
Labyrinthe()
- Source:
Fonction créant un labyrinthe de nombres Le tableau de nombres doit être de format [6][3] Le niveau doit être un entier entre 1 et 6 inclus
LatexParCoordonnees(texte, x, y, color, largeur, hauteur, colorBackground, tailleCaracteres)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
texte |
String | Le code latex qui sera mis en mode math en ligne. Ex : '\dfrac{4}{5}\text{cm}' |
x |
Number | abscisse du point de centrage |
y |
Number | ordonnée du point de centrage |
color |
String | couleur |
largeur |
Number | Dimensions de la 'box' rectangulaire conteneur de la formule en pixels en considérant la taille de caractère 8='\footnotesize' |
hauteur |
Number | Idem pour la hauteur de la box. Prévoir 20 par exemple pour une fraction. Permet le centrage correct. |
colorBackground |
String | Couleur du fond de la box. Chaine vide pour un fond transparent. |
tailleCaracteres |
Number | Taille de la police utilisée de 5 = \small à 20=\huge... agit sur la box en en modifiant les paramètres hauteur et largeur |
latexParPoint()
- Source:
latexParPoint('\dfrac{3}{5}',A,'black',12,20,"white") Ecrit la fraction 3/5 à l'emplacement du label du point A en noir, avec un fond blanc. 12 est la largeur en pixels 20 la hauteur en pixels (utilisé à des fins de centrage). Pour un bon centrage sur A, il faut que A.positionLabel='center'. si colorBackground="", le fond est transparent. tailleCaracteres est à 8 par défaut et correspond à \footnotesize. tailleCaracteres va de 5 = \small à 20 = \huge
leveCrayon(lutin)
- Source:
Fait sortir le lutin du mode "trace"
Parameters:
Name | Type | Description |
---|---|---|
lutin |
objet |
listeEntiersDepuisSomme(nbElements, total) → {Array}
- Source:
Construit un tableau d'entiers de longueur connue dont la somme des éléments est égale à un total connu.
Example
> listeEntiersDepuisSomme(100,3)
< [34,29,37]
Parameters:
Name | Type | Description |
---|---|---|
nbElements |
int | Nombre d'entiers dans le tableau |
total |
int | Somme des éléments du tableau |
Returns:
Tableau d'entier
- Type
- Array
listerFractionsSimplifiees(n, d)
- Source:
Renvoie l'ensemble des fractions égales et simplifiées Ne change pas et ne déplace pas les signes (s'il y a un "-" au dénominateur, il restera au dénominateur)
Parameters:
Name | Type | Description |
---|---|---|
n |
number | |
d |
number |
Returns:
array de couples [numerateur, denominateur] de l'ensemble des fractions égales et simplifiées
listerFractionsSimplifiees(n, d)
- Source:
Renvoie l'ensemble des fractions égales et simplifiées Ne change pas et ne déplace pas les signes (s'il y a un "-" au dénominateur, il restera au dénominateur)
Parameters:
Name | Type | Description |
---|---|---|
n |
number | |
d |
number |
Returns:
array de couples [numerateur, denominateur] de l'ensemble des fractions égales et simplifiées
liToDiv()
- Source:
Transforme les li de classe question en div avec le même contenu
loadGiac() → {Promise}
- Source:
Charge giac
Returns:
qui peut échouer…
- Type
- Promise
loadIep(elt, xml) → {Promise.<iepApp>}
- Source:
Charge une animation iep dans un élément
Parameters:
Name | Type | Description |
---|---|---|
elt |
HTMLElement | |
xml |
string | Le script xml de l'animation ou son url absolue |
Returns:
L'appli iep
- Type
- Promise.<iepApp>
loadMathLive()
- Source:
Charge MathLive et personnalise les réglages MathLive est chargé dès qu'un tag math-field est créé
loadMG32(elt, svgOptions, mtgOptions) → {Promise.<MtgApp>}
- Source:
Charge mathgraph dans l'élément fourni
Parameters:
Name | Type | Description |
---|---|---|
elt |
HTMLElement | |
svgOptions |
Object | Options du svg créé (taille et id, cf https://www.mathgraph32.org/documentation/loading/global.html#mtgLoad) |
mtgOptions |
Object | Options pour l'appli (boutons, menus, etc., cf https://www.mathgraph32.org/documentation/loading/global.html#MtgOptions |
Returns:
l'appli mathgraph https://www.mathgraph32.org/documentation/loading/MtgApp.html
- Type
- Promise.<MtgApp>
loadPrism() → {Promise.<undefined>}
- Source:
Charge prism
Returns:
- Type
- Promise.<undefined>
loadScratchblocks() → {Promise}
- Source:
Charge scratchblocks
Returns:
qui peut échouer…
- Type
- Promise
longueur(A, B, arrondiopt)
- Source:
Renvoie la distance de A à B
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
arrondi |
integer |
<optional> |
2
|
Nombre de chiffres après la virgule. Facultatif, 2 par défaut. |
masquer(objet, param1)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
objet |
string | 'regle', 'equerre', 'requerre, 'compas', 'rapporteur' ou 'crayon' |
param1 |
objet |
mathalea2d()
- Source:
mathalea2d(xmin,xmax,ymin,ymax,objets)
medianeTriangle(A, B, C, color)
- Source:
Médiane issue de A relative à [BC]
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
C |
Point | |
color |
string |
mediatrice(A, B, nomopt, coloropt) → {Droite}
- Source:
Renvoie la médiatrice de [AB] nommée nom de couleur color
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
nom |
string |
<optional> |
''
|
Facultatif, vide par défaut |
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut |
Returns:
Droite
- Type
- Droite
mettrexA(x, lutin)
- Source:
Change en x à l'abscisse du lutin
Parameters:
Name | Type | Description |
---|---|---|
x |
number | |
lutin |
Objet |
mettreyA(y, lutin)
- Source:
change en y l'ordonnée du lutin
Parameters:
Name | Type | Description |
---|---|---|
y |
number | |
lutin |
Objet |
mg32DisplayAll()
- Source:
Affiche toutes les figures
milieu()
- Source:
M = milieu(A,B) //M est le milieu de [AB] M = milieu(A,B,'M') //M est le milieu [AB] et se nomme M M = milieu(A,B,'M','below') //M est le milieu [AB], se nomme M et le nom est en dessous du point
montrer(objet, A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
objet |
string | 'regle', 'equerre', 'requerre, 'compas', 'rapporteur' ou 'crayon' |
A |
point | Point (0, 0) par défaut |
options |
objet | { tempo : 10 } |
montrerParDiv(id)
- Source:
Rend visible un element d'après son id
Parameters:
Name | Type | Description |
---|---|---|
id |
string |
motifs(index)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
index |
number | Choix du motif le nom du motif sert dans la fonction pattern |
multiplieEntier(n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
coefficient |
Returns:
La fractionX multipliée par n (numérateur n fois plus grand)
multiplieEntier(n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
coefficient |
Returns:
La fractionX multipliée par n (numérateur n fois plus grand)
NommePolygone()
- Source:
nommePolygone (p,'ABCDE',0.5) nomme les sommets du polygone p. Les labels sont placés à une distance paramètrable en cm des sommets (0.5 par défaut)
NomVecteurParPosition()
- Source:
norme()
- Source:
norme(V) renvoie la norme du vecteur
onError(event) → {boolean}
- Source:
Appelé avant d'envoyer le rapport, pour filtrer
Parameters:
Name | Type | Description |
---|---|---|
event |
Returns:
- Type
- boolean
oppose()
- Source:
Returns:
l'opposé de la FractionX
oppose()
- Source:
Returns:
l'opposé de la FractionX
orienter(a, lutin)
- Source:
Fixe l'orientation du lutin à a degrés (au sens Mathalea2d=trigo) Voire la fonction angleScratchTo2d(angle_scratch) pour la conversion
Parameters:
Name | Type | Description |
---|---|---|
a |
number | |
lutin |
objet |
orthoCentre(A, B, C, color)
- Source:
Orthocentre du triangle ABC
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
C |
Point | |
color |
string |
parallelogramme2points1hauteur(NOM, A, B, h) → {polygoneAvecNom}
- Source:
parrallelogramme2points1hauteur(A,B,5) renvoie un parallélogramme ABCD de base [AB] et de hauteur h parrallelogramme2points1hauteur(A,7,5) renvoie un parallélogramme ABCD de base 7cm (le point B est choisi sur le cercle de centre A et de rayon 7cm) et de hauteur h
Parameters:
Name | Type | Description |
---|---|---|
NOM |
String | |
A |
objet | |
B |
objet | |
h |
number |
Returns:
- Type
- polygoneAvecNom
parallelogramme2sommetsConsecutifsCentre(A, B, O, nomC, nomD, description)
Trace le parallélogramme ABCD de centre O à partir de [AB] et O.
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
B |
point | |
O |
point | |
nomC |
string | |
nomD |
string | |
description |
boolean |
parallelogramme3points(NOM, A, B, C) → {polygoneAvecNom}
- Source:
function qui retourne le parallélogramme ABCD dont on donne les 3 premiers points A, B et C
Parameters:
Name | Type | Description |
---|---|---|
NOM |
string | |
A |
objet | |
B |
objet | |
C |
objet |
Returns:
- Type
- polygoneAvecNom
parallelogramme3sommetsConsecutifs(A, B, C, nomD, description, csDejaTraces)
Trace un parallélogramme à partir de la donnée de 3 sommets consécutifs
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
B |
point | |
C |
point | |
nomD |
string | |
description |
boolean | |
csDejaTraces |
boolean | À true (par défaut), les 2 côtés seront faits immédiatement, sinon, on les tracera à la règle. |
parallelogrammeAngleCentre(D, A, B, O)
Trace la parallélogramme ABCD de centre O en partant de [AD), [AB) et O (mais sans voir la position de B et D au départ)
Parameters:
Name | Type | Description |
---|---|---|
D |
point | |
A |
point | |
B |
point | |
O |
point |
partageSegment(A, B, n, d, options)
Macro pour placer le point M sur un segment [AB] tel que AM = n/d AB
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
B |
point | |
n |
int | numérateur |
d |
int | dénominateur |
options |
object | { distance: 1, monAngle: 40, nom: '', nommerGraduations: false } |
Returns:
M
pattern(param0)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
param0 |
object | paramètres de définition du motif de remplissage définit un motif de remplissage pour les polygones, les rectangles... ou tout élément SVG qui se remplit. |
pause()
- Source:
Met l'animation en pause forçant l'utilisateur à appuyer sur lecture pour voir la suite
Pavage()
- Source:
Classe Pavage : permet de créer des pavages de polygones en un tour de main et de manipuler les polygones qu'il contient
Pave(Longueur, largeur, profondeur)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
Longueur |
int | |
largeur |
int | |
profondeur |
int |
paveLPH3d(x, y, z, c, p, l, h, color) → {object}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
x |
number | coordonnées du sommet en bas à gauche |
y |
number | |
z |
number | |
c |
number | longueur de l'unité |
p |
number | profondeur |
l |
number | longueur |
h |
number | hauteur |
color |
* | couleur |
Returns:
- Type
- object
Plot(x, y, param2)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
x |
number | abscisse |
y |
number | ordonnée |
param2 |
object | permet de définir le rayon du 'plot', sa couleur, sa couleur de remplissage |
Point()
- Source:
A = point('A') //son nom A = point(x,y) //ses coordonnées A = point(x,y,'A') //ses coordonnées et son nom A = point(x,y,'A',below') //ses coordonnées,son nom et la position de son label
point(x, y, A, labelPosition) → {Point}
- Source:
Crée un objet Point ayant les propriétés suivantes :
Parameters:
Name | Type | Description |
---|---|---|
x |
number | abscisse |
y |
number | ordonnée |
A |
string | son nom qui apparaîtra |
labelPosition |
string | Les possibilités sont : 'left', 'right', 'below', 'above', 'above right', 'above left', 'below right', 'below left'. Si on se trompe dans l'orthographe, ce sera 'above left' et si on ne précise rien, pour un point ce sera 'above'. |
Returns:
- Type
- Point
pointAdistance()
- Source:
Examples
pointAdistance(A,d,angle,nom="",positionLabel="above") // Seuls le point A et la distance d sont obligatoires, angle peut être choisi : il s'agit de l'angle signé avec l'axe [OI) sinon, il est choisi aléatoirement.
p=pointAdistance(A,5,'M') // Place un point aléatoirement à 5 unités de A et lui donne le nom de 'M'.
PointCliquable(x, y, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
x |
number | abscisse du point |
y |
number | ordonnée du point |
options |
object | over, out et click sont des ojets pour le style css des évènements de la souris, radius, width, color, opacite, size, style sont les paramètres possibles pour la trace du point |
pointCreer(A, options)
- Source:
Crééer un point avec la croix pour le situer et son nom en bas à droite par défaut. L'id sera sauvegardé dans l'objet point. S'il n'est pas défini alors on prend le premier entier disponible.
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet | { label: A.nom, tempo: this.tempo, couleur: this.couleurPoint, couleurLabel: this.couleurTexte, id } |
pointDansRepere(x, y, repere)
- Source:
Place un point dans un repère (en récupérant xUnite et yUnite d'un objet repère)
Parameters:
Name | Type | Description |
---|---|---|
x |
integer | |
y |
integer | |
repere |
object |
pointDeplacer(A, x, y, options)
- Source:
Anime la translation d'un point
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
x |
int | Abscisse du point d'arrivée |
y |
int | Ordonnée du point d'arrivée |
options |
objet | Défaut : { tempo: this.tempo, vitesse: this.vitesse } |
pointEnPolygone(lePoint, lePolygone) → {boolean}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
lePoint |
Point | |
lePolygone |
Polygone |
Returns:
true si lePoint est à l'intérieur de lePolygone
- Type
- boolean
pointIntersectionCC()
- Source:
M = pointIntersectionCC(c1,c2,'M') // M est le point d'intersection le plus haut des cercles c1 et c2 M = pointIntersectionCC(c1,c2,'M',2) // M est le point d'intersection le plus bas des cercles c1 et c2 La fonction ne renvoie rien si les cercles n'ont pas de points d'intersection
pointIntersectionDD(d1, d2, Mopt, positionLabelopt) → {Point}
- Source:
Renvoie 'M' le point d'intersection des droites d1 et d2
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
d1 |
Droite | |||
d2 |
Droite | |||
M |
string |
<optional> |
''
|
Nom du point d'intersection. Facultatif, vide par défaut. |
positionLabel |
string |
<optional> |
'above'
|
Facultatif, 'above' par défaut. |
Returns:
Point 'M' d'intersection de d1 et de d2
- Type
- Point
pointIntersectionLC(d, C, nom, n)
- Source:
Example
I = pointItersectionLC(d,c,'I',1) // I est le premier point d'intersection si il existe de la droite (d) et du cercle (c)
Parameters:
Name | Type | Description |
---|---|---|
d |
Droite | la droite qui intecepte (ou pas le cercle) |
C |
Cercle | le cercle |
nom |
string | le nom du point d'intersection |
n |
entier | 1 pour le premier point, 2 sinon. Si il n'y a qu'un seul point d'intesection, l'un ou l'autre renvoie ce point. |
pointMasquer(A, options)
- Source:
Masquer un point
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet | Défaut : { tempo: 0 } |
pointMontrer(A, options)
- Source:
Montrer un point qui aurait été caché
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet | Défaut ; { tempo : this.tempo } |
pointNommer(A, nom, options)
- Source:
Ajoute un label au point
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
nom |
string | |
options |
objet | dx pour le déplacement vertical du nom du point, dy pour le déplacemetn horizontal, couleur: this.couleurPoint, tempo: this.tempo |
pointsCreer(…points)
- Source:
Création de plusieurs points Le dernier argument peut être une option qui sera appliquée à tous les points
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
points |
points |
<repeatable> |
Points séparés par des virgules |
pointSurCercle(c, angle, nom, positionLabel)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
c |
Cercle | |
angle |
number | |
nom |
string | |
positionLabel |
string | M = pointSurCercle(c,'','M') // M est un point choisi au hasard sur le cercle c et se nomme M. N = pointSurCercle(c,90) // N est le point du cercle c situé à 90° par rapport à l'horizontale, donc au dessus du centre de c P = pointSurCercle(c,-90) // P est le point du cercle c situé à l'opposé du point N précédent. |
pointSurDroite(d, x, nom, positionLabelopt) → {Point}
- Source:
Retourne un point sur la droite d dont l'abscisse est x. Si c'est impossible (droite verticale) alors ce sera le point dont l'ordonnée vaut x.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
d |
Droite | |||
x |
number | Abscisse du point |
||
nom |
string | Nom du point |
||
positionLabel |
string |
<optional> |
'above'
|
Facultatif, 'above' par défaut. |
Returns:
Point de la droite d dont l'abscisse est x
- Type
- Point
pointSurSegment()
- Source:
M = pointSurSegment(A,B,l) //M est le point de [AB] à l cm de A M = pointSurSegment(A,B,l,'M') //M est le point de [AB] à l cm de A et se nomme M M = pointSurSegment(A,B,l,'M','below') //M est le point de [AB] à l cm de A, se nomme M et le nom est en dessous du point
M = pointSurSegment(A,B,'h','M') // M est un point au hasard sur [AB] (on peut écrire n'importe quel texte à la place de 'h') M = pointSurSegment(A,B) // M est un point au hasard sur [AB] Sécurité ajoutée par Jean-Claude Lhote : si AB=0, alors on retourne A
Polygone()
- Source:
polygone(A,B,C,D,E) //Trace ABCDE polygone([A,B,C,D],"blue") // Trace ABCD en bleu
polygone() → {Polygone}
- Source:
Examples
polygone(A,B,C,D,E) //Trace ABCDE
polygone([A,B,C,D],"blue") // Trace ABCD en bleu
Returns:
objet Polygone
- Type
- Polygone
polygoneAvecNom(…args)
- Source:
Crée un groupe d'objets contenant le polygone et ses sommets
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
args |
any |
<repeatable> |
Returns:
[p, p.sommets]
polygoneRapide(…sommets)
- Source:
Trace un polygone avec traitRapide()
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
sommets |
points |
<repeatable> |
du polygonne séparés par des virgules |
polygoneRegulier(A, B, n, coloropt)
- Source:
Trace le polygone régulier direct à n côtés qui a pour côté [AB]
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
n |
integer | Nombre de côtés |
||
color |
string |
<optional> |
'black'
|
Facultatif |
polygoneRegulierIndirect()
- Source:
polygoneRegulierIndirect(A,B,n) //Trace le polygone régulier indirect à n côtés qui a pour côté [AB]
polygoneRegulierParCentreEtRayon()
- Source:
polygoneRegulierParCentreEtRayon(O,r,n) //Trace le polygone régulier à n côtés et de rayon r
polygoneTracer(…sommets)
- Source:
Trace un polygone avec les options par défaut que l'on ne peut pas changer ici
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
sommets |
points |
<repeatable> |
du polygonne séparés par des virgules |
Polyline()
- Source:
polyline(A,B,C,D,E) //Trace la ligne brisée ABCDE
positionLabelDroite(d, param1)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
d |
droite | |
param1 |
Object | les bordures de la fenêtre |
Returns:
le point qui servira à placer le label.
produitFraction(f2)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
f * FractionX // retourne un résultat simplifié
produitFraction(f2)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
f * FractionX // retourne un résultat simplifié
produitFractions(…fractions)
- Source:
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
fractions |
any |
<repeatable> |
Returns:
produit de FractionX par toutes les fractions passées en argument.
produitFractions(…fractions)
- Source:
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
fractions |
any |
<repeatable> |
Returns:
produit de FractionX par toutes les fractions passées en argument.
projectionOrtho()
- Source:
N = projectionOrtho(M,d,'N','below left')
propositionsQcm(exercice, i) → {object}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
exercice |
exercice | |
i |
i | indice de la question |
Returns:
{texte, texteCorr} le texte à ajouter pour la question traitée
- Type
- object
puissanceFraction(n) → {FractionX}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
number | l'exposant de la fraction |
Returns:
La puissance n de la fraction
- Type
- FractionX
puissanceFraction(n) → {FractionX}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
n |
number | l'exposant de la fraction |
Returns:
La puissance n de la fraction
- Type
- FractionX
questionJamaisPosee(i, …args) → {boolean}
- Source:
Compare chaque nouvelle version d'un exercice aux précédentes pour s'assurer de ne pas avoir deux exercices identiques
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
i |
int | indice de la question |
|
args |
any |
<repeatable> |
toutes les variables pertinentes qui "résumeraient" la question |
Returns:
true si la question n'a jamais été posée
- Type
- boolean
racineCarree(detaillee) → {FractionX}
- Source:
Retourne la racine carrée de la fraction si c'est une fraction et false sinon
Parameters:
Name | Type | Description |
---|---|---|
detaillee |
boolean | Si detaillee est true, une étape de calcul se place avant le résultat. |
Returns:
- Type
- FractionX
racineCarree(detaillee) → {FractionX}
- Source:
Retourne la racine carrée de la fraction si c'est une fraction et false sinon
Parameters:
Name | Type | Description |
---|---|---|
detaillee |
boolean | Si detaillee est true, une étape de calcul se place avant le résultat. |
Returns:
- Type
- FractionX
rapporteur(semi, avecNombre, precisionAuDegre, stepGraduation, rayonsVisibles, param0) → {Rapporteur}
- Source:
place un rapporteur centré en (x,y) avec le zéro orienté à depart degrés.
Parameters:
Name | Type | Description |
---|---|---|
semi |
boolean | si semi === false alors les graduations vont de 0 à 180° sinon de 0 à 360° |
avecNombre |
string | === "", il n'y a pas de graduations, si avecNombre === "deuxSens" il est gradué dans les deux directions si avecNombre === "unSens" il est gradué dans le sens trigo. |
precisionAuDegre |
number | === 10 alors il n'y aura pas de graduations entre les multiples de 10°, les autres valeurs sont 5 et 1. |
stepGraduation |
number | est un multiple de 10 qui divise 180 (c'est mieux) donc 10 (par défaut), ou 20, ou 30, ou 60 ou 90. |
rayonsVisibles |
boolean | = false permet de supprimer les rayons et le cercle central |
param0 |
object | = {x: 'number', y: 'number', taille: 'number', semi: boolean, avecNombre: string} |
Returns:
// crée un instance de l'objet 2d Rapporteur
- Type
- Rapporteur
rapporteurCrayonMarqueAngle(angle, options)
- Source:
Fais une petite marque (couleur et épaisseur d'un trait de construction) sur une graduation du rapporteur
Parameters:
Name | Type | Description |
---|---|---|
angle |
int | |
options |
objet | Défaut : { tempo: this.tempo, vitesse: this.vitesse, couleur: this.couleurTraitsDeConstruction, epaisseur: this.epaisseurTraitsDeConstruction } |
rapporteurDeplacer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
rapporteurDeplacerRotation2Points(A, B, options)
- Source:
Met le rapporteur en position avec le centre en A et le 0 de droite alogné avec le point B
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
B |
point | |
options |
objet | Défaut : { tempo: this.tempo, vitesse: this.vitesse, sens : this.vitesse / 2 } |
rapporteurMasquer(options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
options |
objet |
rapporteurMasquerGraduationsExterieures(options)
- Source:
Masque la graduation externe du rapporteur (laisse l'autre graduation visible)
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo } |
rapporteurMasquerGraduationsInterieures(options)
- Source:
Masque la graduation interne du rapporteur (laisse l'autre graduation visible)
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo } |
rapporteurMontrer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
rapporteurMontrerGraduationsExterieures(options)
- Source:
Montre la graduation extérieure si elle avait été précédemment cachée
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo } |
rapporteurMontrerGraduationsInterieures(options)
- Source:
Montre la graduation interne si elle avait été précédemment cachée
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo } |
rapporteurRotation(angle, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
angle |
int | |
options |
objet |
rapporteurTracerDemiDroiteAngle(A, B, angle, options)
- Source:
Le crayon va faire une marque sur la graduation du rapporteur, le rapporteur va se cacher et on trace une demi-droite dont on peut choisir la "longueur" (par défaut 90% de celle de la règle)
Parameters:
Name | Type | Description |
---|---|---|
A |
point | Centre du rapporteur |
B |
point | Point avec lequel le 0 de droite sera aligné |
angle |
int | |
options |
objet | { longueur: 0.9 * this.regle.longueur, couleur: this.couleur, tempo: this.tempo, vitesse: this.vitesse, sens : this.vitesse / 2, epaisseur: this.epaisseur, pointilles: this.pointilles } |
rapporteurZoom(pourcentage, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
pourcentage |
int | 200 pour doubler la taille |
options |
objet | tempo = 0 par défaut |
recadre(xmin, ymax)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
xmin |
int | |
ymax |
int |
RectangleCliquable(x, y, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
x |
number | abscisse du point |
y |
number | ordonnée du point |
options |
object | over, out et click sont des ojets pour le style css des évènements de la souris, radius, width, color, size, style sont les paramètres possibles pour la trace du point |
reduire(k)
- Source:
On pourra utiliser k = 0.5 pour simplifier par 2 la fraction par exemple.
Parameters:
Name | Type | Description |
---|---|---|
k |
coefficient |
Returns:
La FractionX dont le numérateur et le dénominateur ont été multipliés par k.
reduire(k)
- Source:
On pourra utiliser k = 0.5 pour simplifier par 2 la fraction par exemple.
Parameters:
Name | Type | Description |
---|---|---|
k |
coefficient |
Returns:
La FractionX dont le numérateur et le dénominateur ont été multipliés par k.
regleDemiDroiteOriginePoint(O, A, options)
- Source:
Trace une demi-droite d'origine O passant par A (ou en direction de A si les points sont trop éloignés)
Parameters:
Name | Type | Description |
---|---|---|
O |
point | Origine |
A |
point | Direction |
options |
objet | Défaut {longueur: this.regle.longueur, tempo : this.tempo, vitesse: this.vitesse, sens: this.vitesse / 2} |
regleDeplacer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
regleDroite(A, B, options)
- Source:
Trace une droite passanrt par les points A et B
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
B |
point | |
options |
objet | Défaut {longueur: this.regle.longueur, tempo : this.tempo, vitesse: this.vitesse, sens: this.vitesse / 2} |
regleMasquer(options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
options |
objet |
regleMasquerGraduations(options)
- Source:
Masquer les graduations sur la règle
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo } |
regleModifierLongueur(longueur, options)
- Source:
Modifie la taille de la règle
Parameters:
Name | Type | Default | Description |
---|---|---|---|
longueur |
int |
20
|
|
options |
objet | Défaut : { tempo: this.tempo } |
regleMontrer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
regleMontrerGraduations(options)
- Source:
Montrer les graduations sur la règle si elles avaient été masquées
Parameters:
Name | Type | Description |
---|---|---|
options |
objet | Défaut : { tempo: this.tempo } |
regleProlongerSegment(A, B, options)
- Source:
Avec la règle, on prolonge le segment de l cm du coté de la 2e extrémité si l est positif sinon du côté de la première extrémité
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
B |
point | |
options |
objet | Défaut {longueur: 3, tempo: this.tempo, vitesse: this.vitesse, sens: this.vitesse / 2} |
regleRotation(angle, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
angle |
int | |
options |
objet |
regleSegment(Segment, options, options) → {id}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
Segment |
segment/point | à tracer ou première extrémité |
options |
objet/point | ou deuxième extrémité |
options |
objet | si les deux premiers arguments étaient des points |
Returns:
identifiant utilisé pour le trait
- Type
- id
regleZoom(pourcentage, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
pourcentage |
int | 200 pour doubler la taille |
options |
objet | tempo = 0 par défaut |
renommePolygone()
- Source:
Renomme en une fois tous les sommets d'un polygone avec le tableau de string fourni
Repere()
- Source:
La fonction Repere n'est pas documentée. Elle est remplacée par la fonction Repere2 qui l'est. Voir ci-dessous.
Repere2()
- Source:
repere2({xUnite, yUnite, xMin, xMax, yMin, yMax, axeX, axeY, axesEpaisseur, axesCouleur, axeXStyle, axeYStyle, thickEpaisseur, thickHauteur, thickCouleur, xThickDistance, xThickListe, xThickMin, xThickMax, yThickDistance, yThickListe, yThickMin, yThickMax, xLabelDistance, xLabelListe, xLabelMin, xLabelMax, yLabelDistance, yLabelListe, yLabelMin, yLabelMax, xLegende,xLegendePosition, yLegende, yLegendePosition, grille, grilleDistance, grilleCouleur,grilleOpacite, grilleEpaisseur, grilleSecondaire, grilleSecondaireDistance, grilleSecondaireCouleur, grilleSecondaireOpacite, grilleSecondaireEpaisseur, grilleX, grilleXListe, grilleXDistance, grilleXMin, grilleXMax, grilleXCouleur, grilleXOpacite, grilleY, grilleYListe, grilleYDistance, grilleYMin, grilleYMax, grilleYCouleur, grilleYOpacite, grilleSecondaireX, grilleSecondaireXListe, grilleSecondaireXDistance, grilleSecondaireXMin, grilleSecondaireXMax, grilleSecondaireXCouleur, grilleSecondaireXOpacite, grilleSecondaireY, grilleSecondaireYListe, grilleSecondaireYDistance, grilleSecondaireYMin, grilleSecondaireYMax, grilleSecondaireYCouleur, grilleSecondaireYOpacite})
repere2() trace un repère classique. De nombreux paramètres permettent d'en modifier l'aspect
repere2(param0)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
param0 |
object |
replaceQueryParam(param, newval, search)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
param |
string | |
newval |
string | |
search |
string |
Returns:
string
representation(x, y, rayon, depart, type, couleur, unite0, unite1, scale, label)
- Source:
Parameters:
Name | Type | Default | Description |
---|---|---|---|
x |
number | position du dessin |
|
y |
number | ||
rayon |
number | rayon du disque |
|
depart |
number |
0
|
numéro du secteur où commence le coloriage |
type |
string |
gateau
|
type parmis : 'gateau', 'segment' et 'barre' |
couleur |
string |
gray
|
|
unite0 |
number |
0
|
Nombre marquant le départ du segment |
unite1 |
number |
1
|
Nombre marquant le point unité du segment |
scale |
number |
1
|
échelle |
label |
string | ce qu'il faut écrire sous le segment ... x ? |
Returns:
objets mathalea2d
representation(x, y, rayon, depart, type, couleur, unite0, unite1, scale, label)
- Source:
Parameters:
Name | Type | Default | Description |
---|---|---|---|
x |
number | position du dessin |
|
y |
number | ||
rayon |
number | rayon du disque |
|
depart |
number |
0
|
numéro du secteur où commence le coloriage |
type |
string |
gateau
|
type parmis : 'gateau', 'segment' et 'barre' |
couleur |
string |
gray
|
|
unite0 |
number |
0
|
Nombre marquant le départ du segment |
unite1 |
number |
1
|
Nombre marquant le point unité du segment |
scale |
number |
1
|
échelle |
label |
string | ce qu'il faut écrire sous le segment ... x ? |
Returns:
objets mathalea2d
representationIrred(x, y, rayon, depart, type, couleur, unite0, unite1, scale, label)
- Source:
Parameters:
Name | Type | Default | Description |
---|---|---|---|
x |
number | position du dessin |
|
y |
number | ||
rayon |
number | rayon du disque |
|
depart |
number |
0
|
numéro du secteur où commence le coloriage |
type |
string |
gateau
|
type parmis : 'gateau', 'segment' et 'barre' |
couleur |
string |
gray
|
|
unite0 |
number |
0
|
Nombre marquant le départ du segment |
unite1 |
number |
1
|
Nombre marquant le point unité du segment |
scale |
number |
1
|
échelle |
label |
string | ce qu'il faut écrire sous le segment ... x ? |
Returns:
objets mathalea2d
representationIrred(x, y, rayon, depart, type, couleur, unite0, unite1, scale, label)
- Source:
Parameters:
Name | Type | Default | Description |
---|---|---|---|
x |
number | position du dessin |
|
y |
number | ||
rayon |
number | rayon du disque |
|
depart |
number |
0
|
numéro du secteur où commence le coloriage |
type |
string |
gateau
|
type parmis : 'gateau', 'segment' et 'barre' |
couleur |
string |
gray
|
|
unite0 |
number |
0
|
Nombre marquant le départ du segment |
unite1 |
number |
1
|
Nombre marquant le point unité du segment |
scale |
number |
1
|
échelle |
label |
string | ce qu'il faut écrire sous le segment ... x ? |
Returns:
objets mathalea2d
requerreDeplacer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
requerreGlisserEquerre(déplacement, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
déplacement |
int | en nombre de cm (le déplacement peut être positif ou négatif) |
options |
* | Défaut : { tempo: this.tempo, vitesse: this.vitesse } |
requerreMasquer(options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
options |
objet |
requerreMontrer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
requerreRotation(angle, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
angle |
int | |
options |
objet |
requerreZoom(pourcentage, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
pourcentage |
int | 200 pour doubler la taille |
options |
objet | tempo = 0 par défaut |
resoudre(params, equation)
- Source:
Retourne toutes les étapes de résolution d'une équation ou d'une inéquation
Example
resoudre('2*x+4=4*x-5') --> Donne les étapes de la résolution de l'équation
resoudre('2*x+4=4*x-5'), {comment: true}) --> Ajoute les commentaires
resoudre('2*x+4=4*x-5', {color: blue}) -> Met en bleu les changements à chaque étape
resoudre('2*x+4=4*x-5', {substeps: true}) --> Ajoute les sous-étapes
resoudre('2*x+4=4*x-5', {produitsencroix: true}) --> Utilise les produits en croix lorsque l'inconnue est au dénominateur a/f(x)=b/c
resoudre('2*x+4=4*x-5', {verifications: true}) --> Ajoute les vérifications de la solution
resoudre('a*x+c=b*x+d', {variables: {a: true, b: true, c: true, d: true, test: 'a!=b'}}) --> a, b, c et d sont choisis au hasard voir la fonction aleaVariables()
resoudre('2*x+4=4*x-5', {comment: true, comments: commentairesPersonnalises}) --> commentairesPersonnalises est un tableau avec des commentaires personnalisés (voir fonction commentStep())
Parameters:
Name | Type | Description |
---|---|---|
params |
Objet | // Les paramètres (commentaires visibles) |
equation |
string | // Une équation ou une inéquation |
rotation(A, O, angle, nomopt, positionLabelopt)
- Source:
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point, Polygone, Droite, Segment ou Vecteur |
|||
O |
Point | Centre de rotation |
||
angle |
number | Angle de rotation |
||
nom |
string |
<optional> |
''
|
Nom de l'image. Facultatif, vide par défaut |
positionLabel |
string |
<optional> |
'above'
|
Facultatif, 'above' par défaut |
Returns:
L'image de A par la rotation de centre O et d'angle angle
rotation(objet, angle, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
objet |
string | 'regle', 'equerre', 'requerre, 'compas', 'rapporteur' ou 'crayon' |
angle |
int | |
options |
objet |
rotation3d(point3D, droite3D, angle, color)
- Source:
LA ROTATION D'AXE UNE DROITE
Parameters:
Name | Type | Description |
---|---|---|
point3D |
Point3d | Pour l'instant on ne fait tourner qu'un point3d Remarque : ça n'a aucun sens de faire tourner un vecteur autour d'une droite particulière, on utilise la rotation vectorielle pour ça. |
droite3D |
Droite3d | Axe de rotation |
angle |
Number | Angle de rotation |
color |
string | couleur du polygone créé. si non précisé la couleur sera celle du polygone argument |
RotationAnimee()
- Source:
rotationAnimee(s,O,a) //Animation de la rotation de centre O et d'angle a pour s rotationAnimee([a,b,c],O,a) //Animation de la rotation de centre O et d'angle a pour les objets a, b et c
rotationV3d(point3D, vecteur3D, angle)
- Source:
LA ROTATION VECTORIELLE
Parameters:
Name | Type | Description |
---|---|---|
point3D |
* | pour l'instant, cette fonction ne fait tourner qu'un point3d ou un vecteur3d |
vecteur3D |
* | vecteur directeur de l'axe de rotation (l'axe passe par l'origine, pour tourner autour d'une droite particulière on utilise rotation3d()) |
angle |
* | Angle de rotation |
scratchblock()
- Source:
Traducteur scratch3 (Latex) -> scratchblocks On lui passe une chaine de caractères contenant une série de commande Latex du package Latex Scratch3 Elle retourne une chaine de caractères contenant l'équivalent en langage scratchblocks si le contexte est isHtml ! Si le contexte est !isHtml alors elle retourne la chaine passée en argument. http://mirrors.ctan.org/macros/latex/contrib/scratch3/scratch3-fr.pdf https://scratchblocks.github.io
script()
- Source:
Renvoie le script xml
Segment()
- Source:
s = segment(A,B) //Segment d'extrémités A et B s = segment(A,B,'blue') //Segment d'extrémités A et B et de couleur bleue s = segment(x1,y1,x2,y2) //Segment défini par les coordonnées des deux extrémités s = segment(x1,y1,x2,y2,'blue') //Segment défini par les coordonnées des deux extrémités et de couleur bleue
segmentAvecExtremites(…args, color)
- Source:
Examples
segmentAvecExtremites(A,B,'blue')
segmentAvecExtremites(x1,y1,x2,y2,'blue')
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
args |
args |
<repeatable> |
Points ou coordonnées |
color |
string | Facultatif |
segmentCodage(Segment, options, options) → {id}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
Segment |
segment/point | à coder ou première extrémité |
options |
objet/point | ou deuxième extrémité |
options |
objet | si les deux premiers arguments étaient des points. Défaut : { tempo: this.tempo, couleur: this.couleurCodage, codage: '//', } |
Returns:
- Type
- id
segmentCodageMasquer(id, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
id |
int | Identifiant du codage |
options |
objet | Défaut : { tempo: this.tempo } |
segmentCodageMontrer(id, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
id |
int | Identifiant du codage |
options |
objet | Défaut : { tempo: this.tempo } |
segmentsSecants(A, B, C, D) → {boolean}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
C |
Point | |
D |
Point |
Returns:
true si [AB] et [CD] sont sécants
- Type
- boolean
SensDeRotation()
- Source:
SensDeRotation3d()
- Source:
setReponse(exercice, i, a)
- Source:
Précise la réponse attendue
Parameters:
Name | Type | Description |
---|---|---|
exercice |
'objet exercice' | |
i |
'numero de la question' | |
a |
'array || number' |
setUrl()
- Source:
Met à jour l'URL avec la vue et le userId s'ils sont connus
setUrlAndGo()
- Source:
Met à jour l'URL avec la vue et le userId s'ils sont connus et go
setUrlAndGoTab()
- Source:
Met à jour l'URL avec la vue et le userId s'ils sont connus et go
seyes(xmin, ymin, xmax, ymax)
- Source:
Fais un quadrillage avec des grands carreaux.
Pour une sortie LaTeX, il faut penser à ajouter scale = .8
Parameters:
Name | Type | Description |
---|---|---|
xmin |
integer | |
ymin |
integer | |
xmax |
integer | |
ymax |
integer |
similitude(A, O, a, k, nom, positionLabel)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | // Le point dont on veut l'image |
O |
Point | // Le centre de la similitude |
a |
number | // L'angle de la rotation |
k |
number | // le rapport de l'homothétie |
nom |
string | |
positionLabel |
string | M = similitude(B,O,30,1.1,'M') // Le point M est l'image de B dans la similitude de centre O d'angle 30° et de rapport 1.1 |
simplifie()
- Source:
Returns:
la FractionX irreductible
simplifie()
- Source:
Returns:
la FractionX irreductible
sin(a)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
a |
number | angle en degrés |
Returns:
flottant : le sinus de l'angle
sommeFraction(f2)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
f + FractionX
sommeFraction(f2)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
f + FractionX
Sphere3d(centre, rayon, nbParalleles, nbMeridiens, color)
- Source:
LA SPHERE
Parameters:
Name | Type | Description |
---|---|---|
centre |
Point3d | |
rayon |
Number | |
nbParalleles |
Number | |
nbMeridiens |
Number | |
color |
string |
superieurLarge(f)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f |
FractionX | Fraction | nombre |
Returns:
true si FractionX >= f
superieurLarge(f)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f |
FractionX | Fraction | nombre |
Returns:
true si FractionX >= f
superieurstrict(f2) → {boolean}
- Source:
fonctions de comparaison avec une autre fraction.
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
true si
- Type
- boolean
superieurstrict(f2) → {boolean}
- Source:
fonctions de comparaison avec une autre fraction.
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX | Fraction | nombre |
Returns:
true si
- Type
- boolean
svgEngrenages(id_du_div, w, h)
- Source:
Renvoie deux engrenages en HTML pour le moment
Parameters:
Name | Type | Description |
---|---|---|
id_du_div |
string | id unique pour éviter les doublons, généré dans l'exo; à revoir? |
w |
number | largeur du conteneur |
h |
number | hauteur du conteneur |
SymetrieAnimee()
- Source:
symetrieAnimee(s,d) //Animation de la symetrie d'axe (d) pour s symetrieAnimee([a,b,c],d) //Animation de la symetrie d'axe (d) pour les objets a, b et v
symetrieAxiale(A, d, M, positionLabel) → {Point}
- Source:
Renvoie le point M symétrique du point A par la droite d.
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | Objet de type Point (ses coordonnées x et y renseignées) |
d |
droite | Objet de type Droite (son équation ax+by+c=0 renseignée) |
M |
string | Nom de l'image. Facultatif, vide par défaut. |
positionLabel |
string | Facultatif, 'above' par défaut. |
Returns:
M image de A par la symétrie axiale d'axe d.
- Type
- Point
symetrieAxialePoint(p, d, nom, options)
Parameters:
Name | Type | Description |
---|---|---|
p |
objet | point dont on construit l'image et qui doit être tracé. |
d |
objet | axe de symétrie. |
nom |
string | nom de l'image |
options |
objet | couleur et couleurCodage |
Tableau()
- Source:
Réalise un tableau typique des exercices de proportionnalité avec d'éventuelles flèches
TableauDeVariation(param0)
- Source:
Classe TableauDeVariation Initiée par Sebastien Lozano, transformée par Jean-Claude Lhote publié le 9/02/2021 tabInit est un tableau contenant sous forme de chaine les paramètres de la macro Latex \tabInit{}{} tabLines est un tableau contenant sous forme de chaine les paramètres des différentes macro \tabLine{} exemple : tabInit:[[[texte1,taille1,long1],[texte2,taille2,long2]...],[valeur1,long1,valeur2,long2,valeur3,long3...]] tabLines:[[type,long0,codeL1C1,long1,codeL1C2,long2,codeL1C3,long3...],[type,long0,codeL2C1,long1,codeL2C2,long2,codeL2C3,long3...]]
Parameters:
Name | Type | Description |
---|---|---|
param0 |
* |
taille(width, height)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
width |
int | |
height |
int |
tan(a)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
a |
number | angle en degrés |
Returns:
flottant : la tangente de l'angle
texArrayReponsesCoupleDeFractions(n1, d1, n2, d2, egalesEtSimplifiees) → {n1}
- Source:
Renvoie un array avec l'ensemble de réponses possibles correspondant à un couple de fractions afin de pouvoir les placer dans un setReponse Exemple ['-\frac{a}{b};\frac{c}{d}', '\frac{-a}{b};\frac{c}{d}', '\frac{a}{-b};\frac{c}{d}', '\frac{c}{d};-\frac{a}{b}', '\frac{c}{d};\frac{-a}{b}', '\frac{c}{d};\frac{a}{-b}' ...
Parameters:
Name | Type | Default | Description |
---|---|---|---|
n1 |
number | numérateur 1 |
|
d1 |
number | dénominateur 1 |
|
n2 |
number | numérateur 1 |
|
d2 |
number | dénominateur 1 |
|
egalesEtSimplifiees |
boolean |
false
|
true si on veut inclure l'ensemble des fractions égales et simplifiées |
Returns:
array avec la liste des couples de fractions sous la forme '\frac{d1};\frac{n2}{d2}'
- Type
- n1
texArrayReponsesCoupleDeFractions(n1, d1, n2, d2, egalesEtSimplifiees) → {n1}
- Source:
Renvoie un array avec l'ensemble de réponses possibles correspondant à un couple de fractions afin de pouvoir les placer dans un setReponse Exemple ['-\frac{a}{b};\frac{c}{d}', '\frac{-a}{b};\frac{c}{d}', '\frac{a}{-b};\frac{c}{d}', '\frac{c}{d};-\frac{a}{b}', '\frac{c}{d};\frac{-a}{b}', '\frac{c}{d};\frac{a}{-b}' ...
Parameters:
Name | Type | Default | Description |
---|---|---|---|
n1 |
number | numérateur 1 |
|
d1 |
number | dénominateur 1 |
|
n2 |
number | numérateur 1 |
|
d2 |
number | dénominateur 1 |
|
egalesEtSimplifiees |
boolean |
false
|
true si on veut inclure l'ensemble des fractions égales et simplifiées |
Returns:
array avec la liste des couples de fractions sous la forme '\frac{d1};\frac{n2}{d2}'
- Type
- n1
texArrayReponsesCoupleDeFractionsEgalesEtSimplifiees(n1, d1, n2, d2) → {n1}
- Source:
Renvoie un array avec l'ensemble de réponses possibles correspondant à un couple de fractions et de leurs différentes simplifications afin de pouvoir les placer dans un setReponse Exemple ['-\frac{a}{b};\frac{c}{d}', '\frac{-a}{b};\frac{c}{d}', '\frac{a}{-b};\frac{c}{d}', '\frac{c}{d};-\frac{a}{b}', '\frac{c}{d};\frac{-a}{b}', '\frac{c}{d};\frac{a}{-b}' ...
Parameters:
Name | Type | Description |
---|---|---|
n1 |
number | numérateur de la 1e fraction |
d1 |
number | dénominateur de la 1e fraction |
n2 |
number | numérateur de la 2e fraction |
d2 |
number | dénominateur de la 2e fraction |
Returns:
array avec la liste des couples de fractions égales et simplifiées sous la forme '\frac{d1};\frac{n2}{d2}'
- Type
- n1
texArrayReponsesCoupleDeFractionsEgalesEtSimplifiees(n1, d1, n2, d2) → {n1}
- Source:
Renvoie un array avec l'ensemble de réponses possibles correspondant à un couple de fractions et de leurs différentes simplifications afin de pouvoir les placer dans un setReponse Exemple ['-\frac{a}{b};\frac{c}{d}', '\frac{-a}{b};\frac{c}{d}', '\frac{a}{-b};\frac{c}{d}', '\frac{c}{d};-\frac{a}{b}', '\frac{c}{d};\frac{-a}{b}', '\frac{c}{d};\frac{a}{-b}' ...
Parameters:
Name | Type | Description |
---|---|---|
n1 |
number | numérateur de la 1e fraction |
d1 |
number | dénominateur de la 1e fraction |
n2 |
number | numérateur de la 2e fraction |
d2 |
number | dénominateur de la 2e fraction |
Returns:
array avec la liste des couples de fractions égales et simplifiées sous la forme '\frac{d1};\frac{n2}{d2}'
- Type
- n1
texArrayReponsesFraction(numerateur, denominateur)
- Source:
Fonction destinée à lister l'ensemble des possibilités d'écriture d'une même fraction pour être comparées dans un setReponse
Parameters:
Name | Type | Description |
---|---|---|
numerateur |
number | |
denominateur |
number |
Returns:
array avec l'ensemble des possibilités d'écriture d'une même fraction au format LateX
texArrayReponsesFraction(numerateur, denominateur)
- Source:
Fonction destinée à lister l'ensemble des possibilités d'écriture d'une même fraction pour être comparées dans un setReponse
Parameters:
Name | Type | Description |
---|---|---|
numerateur |
number | |
denominateur |
number |
Returns:
array avec l'ensemble des possibilités d'écriture d'une même fraction au format LateX
texArrayReponsesFractionsEgalesEtSimplifiees(n, d) → {n}
- Source:
Fonction destinée à être utilisée conjointement avec setReponse Exemple [\frac{18}{6}, \frac{-18}{-6}, -\frac{-18}{6}, -\frac{18}{-6}, \frac{9}{3}, \frac{-9}{-3}, -\frac{-9}{3}, -\frac{9}{-3}, 3]
Parameters:
Name | Type | Description |
---|---|---|
n |
number | numérateur |
d |
number | dénominateur |
Returns:
array avec la liste des fractions égales et simplifiées sous la forme '\frac{d}'
- Type
- n
texArrayReponsesFractionsEgalesEtSimplifiees(n, d) → {n}
- Source:
Fonction destinée à être utilisée conjointement avec setReponse Exemple [\frac{18}{6}, \frac{-18}{-6}, -\frac{-18}{6}, -\frac{18}{-6}, \frac{9}{3}, \frac{-9}{-3}, -\frac{-9}{3}, -\frac{9}{-3}, 3]
Parameters:
Name | Type | Description |
---|---|---|
n |
number | numérateur |
d |
number | dénominateur |
Returns:
array avec la liste des fractions égales et simplifiées sous la forme '\frac{d}'
- Type
- n
texQuotientFraction(f2) → {string}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX |
Returns:
Calcul f/f2 avec les étapes mais sans simplification
- Type
- string
texQuotientFraction(f2) → {string}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
f2 |
FractionX |
Returns:
Calcul f/f2 avec les étapes mais sans simplification
- Type
- string
texRacineCarree(detaillee) → {FractionX}
- Source:
Retourne la chaine latex contenant la racine carrée de la fraction
Parameters:
Name | Type | Default | Description |
---|---|---|---|
detaillee |
boolean |
false
|
Si detaillee est true, une étape de calcul se place avant le résultat. |
Returns:
- Type
- FractionX
texRacineCarree(detaillee) → {FractionX}
- Source:
Retourne la chaine latex contenant la racine carrée de la fraction
Parameters:
Name | Type | Default | Description |
---|---|---|---|
detaillee |
boolean |
false
|
Si detaillee est true, une étape de calcul se place avant le résultat. |
Returns:
- Type
- FractionX
texSimplificationAvecEtapes()
- Source:
Si la fraction est réductible, retourne une suite d'égalités permettant d'obtenir la fraction irréductible
textarea_to_array()
- Source:
Récupère le texte saisi pour le transformer en tableau de tableaux.
Premier séparateur le saut de ligne ; deuxième séparateur le point-virgule.
texteChangeCouleur(texte, id, couleur)
- Source:
Change la couleur d'un texte déjà créé dont on donne l'id retourné par this.textePoint ou this.textePosition Nécessité de redonner le texte car on réécrit le texte dans une autre couleur.
Parameters:
Name | Type | Description |
---|---|---|
texte |
string | |
id |
number | |
couleur |
string |
texteDeplacer(A, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
options |
objet |
texteMasquer(id, options)
- Source:
Masque le trait d'id fourni
Parameters:
Name | Type | Description |
---|---|---|
id |
array | |
options |
objet | Défaut : { tempo: 0 } |
TexteParPoint()
- Source:
texteParPoint('mon texte',A) // Écrit 'mon texte' avec A au centre du texte texteParPoint('mon texte',A,'gauche') // Écrit 'mon texte' à gauche de A (qui sera la fin du texte) texteParPoint('mon texte',A,'droite') // Écrit 'mon texte' à droite de A (qui sera le début du texte) texteParPoint('mon texte',A,45) // Écrit 'mon texte' à centré sur A avec une rotation de 45° Si mathOn est true, la chaine est traitée par texteParPoint mais avec une police se rapprochant de la police Katex (quelques soucis d'alignement des caractères sur certains navigateurs) Si le texte commence et fini par des $ la chaine est traitée par latexParPoint
texteParPosition(texte, x, y, orientation, coloropt, scaleopt, ancrageDeRotationopt, mathOnopt)
- Source:
texteParPosition('mon texte',x,y) // Écrit 'mon texte' avec le point de coordonnées (x,y) au centre du texte.
texteParPosition('mon texte',x,y,'gauche') // Écrit 'mon texte' à gauche du point de coordonnées (x,y) (qui sera la fin du texte)
texteParPosition('mon texte',x,y,'droite') // Écrit 'mon texte' à droite du point de coordonnées (x,y) (qui sera le début du texte)
texteParPosition('mon texte',x,y,45) // Écrit 'mon texte' centré sur le point de coordonnées (x,y) avec une rotation de 45°
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
texte |
string | // Le texte qu'on veut afficher |
||
x |
number | // L'abscisse de la position initiale du texte |
||
y |
number | // L'ordonnée de la position initiale du texte |
||
orientation |
string |
['milieu'
|
// Angle d'orientation du texte ou bien 'milieu', gauche' ou 'droite'. Voir exemple |
|
color |
string |
<optional> |
'black'
|
// Couleur du texte |
scale |
number |
<optional> |
1
|
// Echelle du texte. |
ancrageDeRotation |
string |
<optional> |
'middle'
|
// Choix parmi 'middle', 'start' ou 'end'. En cas d'orientation avec un angle, permet de savoir où est le centre de la rotation par rapport au texte. |
mathOn |
string |
<optional> |
false
|
// Ecriture dans le style de Latex. |
textePoint(texte, A, options) → {id}
- Source:
Ecris un texte collé au point. On peut choisir un fond, un cadre, l'opacité du fond, la police...
Parameters:
Name | Type | Description |
---|---|---|
texte |
string | |
A |
point | |
options |
objet | Défaut : { tempo: this.tempo, police: false, couleur: this.couleurTexte, couleurFond, opaciteFond, couleurCadre, epaisseurCadre, marge, margeGauche, margeDroite, margeHaut, margeBas } |
Returns:
- Type
- id
textePosition(texte, x, y, options)
- Source:
Ecris un texte collé au point de coordonnées (x,y). On peut choisir un fond, un cadre, l'opacité du fond, la police...
Parameters:
Name | Type | Description |
---|---|---|
texte |
string | |
x |
int | Abscisse du coin en haut à gauche |
y |
int | Ordonnée du coin en haut à gauche |
options |
objet | Défaut : { tempo: this.tempo, police: false, couleur: this.couleurTexte, couleurFond, opaciteFond, couleurCadre, epaisseurCadre, marge, margeGauche, margeDroite, margeHaut, margeBas } |
TexteSurArc()
- Source:
texteSurArc(texte, A, B, angle) // Écrit un texte au milieu de l'arc AB, au dessus si A est le point le plus à gauche sinon au dessous
texteSurArc(texte, A, B, angle, coloropt, dopt) → {object}
- Source:
Écrit un texte au milieu de l'arc AB au dessus si A est le point le plus à gauche sinon au dessous
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
texte |
string | Texte à afficher (éviter les $$ pour les affichages diaporama) |
||
A |
Point | Extrémité de l'arc |
||
B |
Point | Extrémité de l'arc |
||
angle |
number | Angle au centre |
||
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut |
d |
number |
<optional> |
0.5
|
Distance à la droite. Facultatif, 0.5 par défaut |
Returns:
LatexParCoordonnees si le premier caractère est '$', TexteParPoint sinon
- Type
- object
TexteSurSegment()
- Source:
texteSurSegment(A,B) // Écrit un texte au milieu de [AB] au dessus si A est le point le plus à gauche sinon au dessous
texteSurSegment(texte, A, B, coloropt, dopt, horizontalopt) → {object}
- Source:
Écrit un texte au milieu de [AB] au dessus si A est le point le plus à gauche sinon au dessous
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
texte |
string | |||
A |
Point | |||
B |
Point | |||
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut |
d |
number |
<optional> |
0.5
|
Distance à la droite. Facultatif, 0.5 par défaut |
horizontal |
boolean |
<optional> |
false
|
Si true, alors le texte est horizontal, sinon le texte est parallèle au segment |
Returns:
LatexParCoordonnees si le premier caractère est '$', TexteParPoint sinon
- Type
- object
toFraction()
- Source:
Convertit la FractionX en Fraction
Returns:
un objet Fraction (mathjs)
toFraction()
- Source:
Convertit la FractionX en Fraction
Returns:
un objet Fraction (mathjs)
toTex(node, params) → {string}
- Source:
Retourne le format Latex d'un node mathjs ou mathsteps ou d'une expression ascii Supprime les parenthèses inutiles, les 1 et les 0 inutiles, transforme les +- en -
Example
toTex('3/2+4*x') -> \dfrac{3}{2}+4x
toTex('1*x+-3=6*x+0') -> x-3=6x
toTex('-3/4') -> -\dfrac{3}{4}
toTex('OA/OM=OB/ON',{OA: 1.2, OM: 1.5, OB: 1.7}) -> \dfrac{1{.}2}{1{.}5}=\dfrac{1{.}7}{OB}
Parameters:
Name | Type | Description |
---|---|---|
node |
string | Object | // Chaine de caractères décrivant une expression mathématique, une équation, une inéquation ou bien node mathjs |
params |
Object | // Paramètres |
Returns:
// Format latex
- Type
- string
tournerD(a, lutin)
- Source:
Fait tourner de a degrés le lutin dans le sens indirect
Parameters:
Name | Type | Description |
---|---|---|
a |
number | |
lutin |
objet |
tournerG(a, lutin)
- Source:
Fait tourner de a degrés le lutin dans le sens direct
Parameters:
Name | Type | Description |
---|---|---|
a |
number | |
lutin |
objet |
TraceBarre(x, hauteur, legende, epaisseur, couleur, opaciteDeRemplissage, angle)
- Source:
Trace une barre pour un histogramme
Parameters:
Name | Type | Description |
---|---|---|
x |
integer | |
hauteur |
integer | |
legende |
string | |
epaisseur |
integer | |
couleur |
string | |
opaciteDeRemplissage |
integer | |
angle |
integer |
TraceBarreHorizontale(longueur, y, legende, epaisseur, couleur, opaciteDeRemplissage, angle)
- Source:
Trace une barre horizontale pour un histogramme
Parameters:
Name | Type | Description |
---|---|---|
longueur |
integer | |
y |
integer | |
legende |
string | |
epaisseur |
integer | |
couleur |
string | |
opaciteDeRemplissage |
integer | |
angle |
integer |
traceCompas()
- Source:
m = traceCompas(O, A, 20) trace un arc de cercle de centre O qui commence 10° avant A et finit 10° après.
TraceGraphiqueCartesien(data, repere)
- Source:
Trace un graphique cartésien dans un repère
Parameters:
Name | Type | Description |
---|---|---|
data |
array | |
repere |
object |
TracePoint()
- Source:
tracePoint(A) // Place une croix à l'emplacement du point A tracePoint(A,B,C,D) // Place une croix pour les différents points tracePoint(A,B,C,D,'blue') // Place une croix pour les différents points
tracePoint(args) → {TracePoint}
- Source:
Parameters:
Name | Type | Description |
---|---|---|
args |
Point | Points précédemment créés. Si le dernier argument est une chaîne de caractère, définit la couleur des points tracés. |
Returns:
TracePoint
- Type
- TracePoint
TracePointSurDroite()
- Source:
P=tracePointSurDroite(A,d) //Ajoute un trait perpendiculaire à d supposée tracée marquant la posiion du point A P=tracePointSurDroite(A,B) //Ajoute un trait perpendiculaire à la droite (AB) supposée tracée marquant la posiion du point A
tracer(B, options) → {id}
- Source:
Le crayon trace un trait de sa position courante jusqu'au point B
Parameters:
Name | Type | Description |
---|---|---|
B |
point | |
options |
objet | Défaut { tempo: this.tempo, vitesse: this.vitesse, epaisseur: this.epaisseur, couleur: this.couleur, pointilles: this.pointilles, vecteur: false } |
Returns:
id utilisée pour le tracé
- Type
- id
trait(A, B, options) → {id}
- Source:
Trace au crayon le segment [AB]
Parameters:
Name | Type | Description |
---|---|---|
A |
point | Première extrémité |
B |
point | Deuxième extrémité |
options |
* |
Returns:
id utilisée pour le tracé
- Type
- id
traitMasquer(id, options)
- Source:
Masque le trait d'id fourni
Parameters:
Name | Type | Description |
---|---|---|
id |
int | |
options |
objet | Défaut : { tempo: 0, vitesse: 200 } |
traitRapide(A, B, options) → {id}
- Source:
Trace au crayon le segment [AB] sans tempo et avec une vitesse multipliée par 1 000
Parameters:
Name | Type | Description |
---|---|---|
A |
point | Première extrémité |
B |
point | Deuxième extrémité |
options |
* |
Returns:
id utilisée pour le tracé
- Type
- id
translation(O, v, nom, positionLabel)
- Source:
M = translation(O,v) //M est l'image de O dans la translation de vecteur v M = translation(O,v,'M') //M est l'image de O dans la translation de vecteur v et se nomme M M = translation(O,v,'M','below') //M est l'image de O dans la translation de vecteur v, se nomme M et le nom est en dessous du point
Parameters:
Name | Type | Description |
---|---|---|
O |
ObjecMathalea2d | objet à translater (Point, Droite, Segment, Polygone ou Vecteur) |
v |
Vecteur | vecteur de translation |
nom |
string | nom du translaté pour un Point |
positionLabel |
string | Position du label pour un Point |
translation2Points()
- Source:
M = translation2Points(O,A,B) //M est l'image de O dans la translation qui transforme A en B M = translation2Points(O,A,B,'M') //M est l'image de O dans la translation qui transforme A en B et se nomme M M = translation2Points(O,A,B,'M','below') //M est l'image de O dans la translation qui transforme A en B, se nomme M et le nom est en dessous du point
translation3d(point3D, vecteur3D)
- Source:
LA TRANSLATION
Parameters:
Name | Type | Description |
---|---|---|
point3D |
Point3d | Pour l'instant on ne translate qu'un point3d ou un polygone3d |
vecteur3D |
Vecteur3d |
TranslationAnimee()
- Source:
translationAnimee(s,v) //Animation de la translation de vecteur v pour s translationAnimee([a,b,c],v) //Animation de la translation de vecteur v pour les objets a, b et v
TranslationPuisRotationAnimee()
- Source:
Comparer aires et/ou périmètres de figures avec ceux d'un rectangle référence Ref 6M21
triangle2points1angle1longueur(A, B, a, l, n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | Le sommet pour l'angle donné = première extrémité du segment de base du triangle |
B |
Point | L'autre extrémité du segment de base |
a |
number | l'angle au sommet A (angle compris entre 0 et 180 sinon il y est contraint) |
l |
number | la longueur du deuxième côté de l'angle |
n |
number | n=1 l'angle a est pris dans le sens direct, n différent de 1, l'angle a est pris dans le sens indirect. t = triangle2points1angle1longueur(A,B,40,6) // Trace le triangle ABC tel que CAB = 40° et AC=6 |
triangle2points1angle1longueurOppose(A, B, a, l, n)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | Le sommet pour l'angle donné = première extrémité du segment de base du triangle |
B |
Point | L'autre extrémité du segment de base |
a |
number | l'angle au sommet A (angle compris entre 0 et 180 sinon il y est contraint) |
l |
number | la longueur du côté opposé à l'angle |
n |
number | n=1 l'angle a est pris dans le sens direct et le point est le plus près de A n=2 l'angle est pris dans le sens indirect et le point est le plus près de A n=3 l'angle a est pris dans le sens direct et le point est le plus loin de A n=4 l'angle est pris dans le sens indirect et le point est le plus loin de A t = triangle2points1angle1longueurOppose(A,B,40,6) // Trace le triangle ABC tel que CAB = 40° et BC=6 Le point C est celui des deux points possible le plus près de A |
triangle2points1hauteur(A, B, h, d, n) → {objet}
- Source:
retourne un objet contenant le triangle ABC et le pied de la hauteur H
Parameters:
Name | Type | Description |
---|---|---|
A |
point | première extrémité de la base |
B |
point | deuxième extrémité de la base |
h |
number | hauteur du triangle en cm |
d |
number | valeur algébrique de AH où H est le pied de la hauteur |
n |
* | = 1 ou 2 permet de choisir le côté pour C. |
Returns:
{triangle, pied}
- Type
- objet
triangle2points2angles()
- Source:
t = triangle2points2angles(A,B,40,60) // Trace le triangle ABC tel que CAB = +40° et CBA = -60° C = t.listePoints[2] // Récupère le 3e sommet dans la variable C t = triangle2points2angles(A,B,40,60,2) // Trace le triangle ABC tel que CAB = -40° et CBA = 60°
triangle2points2longueurs(A, B, l1, l2, nopt) → {Polygone}
- Source:
Examples
t = triangle2points2longueurs(A,B,4,7,2) // Récupère t le triangle ABC tel que AC = 4 cm et BC = 7 cm avec C qui a l'ordonnée la plus petite possible
C = t.listePoints[2] // Récupère le 3e sommet dans la variable C
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
l1 |
number | |||
l2 |
number | |||
n |
number |
<optional> |
1
|
Si n = 1 (défaut), C a la plus grande ordonnée possible, si n = 2, C a la plus petite ordonnée possible |
Returns:
objet Polygone ABC
- Type
- Polygone
trieCouples()
- Source:
Fonction qui trie des couples de coordonnées pour les remettre dans l'ordre des x croissant
txt_to_objet_parametres_exercice()
- Source:
Transforme le texte saisi par l'utilisateur en un dictionnaire avec l'id des exercices et les éventuels paramètres (sup, sup2, nbQuestions)
txt_to_objet_parametres_exercice('6C10,sup=false,nbQuestions=5') {id: "6C10", sup: false, nbQuestions: 5}
updateMessageErreur()
- Source:
Met à jour le message d'erreur en évitant les doublons.
valeurAbsolue()
- Source:
Convertit la FractionX en Fraction
Returns:
un objet Fraction (mathjs)
valeurAbsolue()
- Source:
Convertit la FractionX en Fraction
Returns:
un objet Fraction (mathjs)
Vecteur()
- Source:
v = vecteur('V') // son nom v = vecteur(x,y) // ses composantes v = vecteur(A,B) // son origine et son extrémité (deux Points) v = vecteur(x,y,'v') // son nom et ses composantes.
vecteur()
- Source:
Examples
v = vecteur('V') // son nom
v = vecteur(x,y) // ses composantes
v = vecteur(A,B) // son origine et son extrémité (deux Points)
v = vecteur(x,y,'v') // son nom et ses composantes.
waitFor(id, timeout) → {Promise.<HTMLElement, Error>}
- Source:
Attend qu'un id soit présent dans le dom
Parameters:
Name | Type | Description |
---|---|---|
id |
string | |
timeout |
number | Temps max d'attente (en s) avant de rejeter la promesse |
Returns:
- Type
- Promise.<HTMLElement, Error>
waitForGiac() → {Promise.<undefined, Error>}
- Source:
Attend que xcas soit chargé (max 60s), car giacsimple lance le chargement du wasm|js suivant les cas
Returns:
rejette en cas de timeout
- Type
- Promise.<undefined, Error>
x()
- Source:
*** Fin du constructeur
zoom(objet, pourcentage, options)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
objet |
string | 'regle', 'equerre', 'requerre, 'compas' ou 'rapporteur' |
pourcentage |
int | 200 pour doubler la taille |
options |
objet | tempo = 0 par défaut |
Type Definitions
listeNombres
- Source:
Type:
- Array.<number>