Methods
afficheCoteSegment(s, Coteopt, positionCoteopt, couleurCoteopt, epaisseurCoteopt, positionValeuropt, couleurValeuropt, horizontalopt) → {AfficheCoteSegment}
Affiche la côte d'un segment sous la forme d'une flèche à double sens et d'une valeur associée.
Examples
afficheCoteSegment(s)
// Affiche la côte du segment s (avec une flèche noire d\'épaisseur 1 "cm", placée 0.5 "cm" sous le segment, avec la longueur du segment, en cm, écrite en noir, 0,5 "cm" au-dessus, et parallèle au segment.
afficheCoteSegment(s,'x',-1,'red',2,1,'blue',true)
// Affiche la côte du segment s, avec une flèche rouge d\'épaisseur 2 "cm", placée 1 "cm" sous le segment, avec le texte 'x' écrit en bleu, 1 "cm" au-dessus, et horizontalement.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
s |
Segment | Segment pour lequel on affiche la côte |
||
Cote |
string |
<optional> |
''
|
Si '', alors la longueur en cm est affichée, sinon c'est cette valeur qui s'affiche (et cela peut être une variable). |
positionCote |
number |
<optional> |
0.5
|
Position de la flèche par rapport au segment. Valeur négative ou positive selon la position voulue. |
couleurCote |
string |
<optional> |
'black'
|
Couleur de la flèche : du type 'blue' ou du type '#f15929'. |
epaisseurCote |
number |
<optional> |
1
|
Epaisseur de la flèche. |
positionValeur |
number |
<optional> |
0.5
|
Position de la valeur par rapport à la flèche. Valeur négative ou positive selon la position voulue. |
couleurValeur |
string |
<optional> |
'black'
|
Couleur de la valeur indiquée : du type 'blue' ou du type '#f15929'. |
horizontal |
boolean |
<optional> |
false
|
Si true, alors le texte est horizontal, sinon le texte est parallèle au segment. |
Returns:
- Type
- AfficheCoteSegment
afficheLongueurSegment(A, B, coloropt, dopt, uniteopt, horizontalopt) → {AfficheLongueurSegment}
Affiche la longueur de [AB] au dessus si A est le point le plus à gauche sinon au dessous.
Examples
afficheLongueurSegment(A,B)
// Affiche la longueur du segment [AB] (en noir, à 0,5 "cm" du segment, complétée par l'unité cm et parallèlement au segment).
afficheLongueurSegment(A,B,'blue',1,'mm',true)
// Affiche la longueur du segment [AB], en bleu, à 1 "cm" du segment, complétée par l'unité mm et horizontalement.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Première extrémité du segment |
||
B |
Point | Seconde extrémité du segment |
||
color |
string |
<optional> |
'black'
|
Couleur affichée de la longueur affichée : du type 'blue' ou du type '#f15929'. |
d |
number |
<optional> |
0.5
|
Distance entre l'affichage de la longueur et le segment. |
unite |
string |
<optional> |
'cm'
|
Affiche cette unité après la valeur numérique de la longueur. |
horizontal |
boolean |
<optional> |
false
|
Si true, alors le texte est horizontal, sinon le texte est parallèle au segment. |
Returns:
afficheMesureAngle(A, B, C, coloropt, distanceopt, labelopt, parametres) → {AfficheMesureAngle}
Affiche la mesure de l'angle ABC arrondie au degré près
Examples
afficheMesureAngle(M,N,O)
// Affiche la mesure de l'angle MNO (en noir, avec un arc de rayon 1,5 "cm").
afficheMesureAngle(M,N,O,'red',2,'pop',{ecart:1,saillant:false,colorArc:'blue',rayon:true,couleurDeRemplissage:'#f15929',opaciteDeRemplissage:0.8,arcEpaisseur:2,mesureEnGras:true})
// Affiche le label pop en gras et rouge, sur l'angle rentrant MNO, avec un arc bleu, epais de 2 et de rayon 2 "cm", à 1 "cm" de l'arc rempli en orange avec une opacité de 80%, cerné par ses rayons.
Parameters:
Name | Type | Attributes | Default | Description | |||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
A |
Point | Point sur un côté de l'angle |
|||||||||||||||||||||||||||||||||||||||||||||||
B |
Point | Sommet de l'angle |
|||||||||||||||||||||||||||||||||||||||||||||||
C |
Point | Point sur l'autre côté de l'angle |
|||||||||||||||||||||||||||||||||||||||||||||||
color |
string |
<optional> |
'black'
|
Couleur de la mesure de l'angle : du type 'blue' ou du type '#f15929'. |
|||||||||||||||||||||||||||||||||||||||||||||
distance |
number |
<optional> |
1.5
|
Rayon de l'arc de cercle. |
|||||||||||||||||||||||||||||||||||||||||||||
label |
string |
<optional> |
''
|
Si vide, alors affiche la mesure de l'angle sinon affiche ce label. |
|||||||||||||||||||||||||||||||||||||||||||||
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- AfficheMesureAngle
afficherCrayon(A) → {AfficherCrayon}
- Source:
Properties:
Name | Type | Description |
---|---|---|
svg |
string | sortie au format vectoriel (SVG) que l’on peut afficher dans un navigateur |
Afficher (en HTML) un crayon avec la mine sur le point A
Parameters:
Name | Type | Description |
---|---|---|
A |
point |
Returns:
- Type
- AfficherCrayon
afficherTempo(objet, t0opt, topt, ropt)
- Source:
Masque un objet pendant t0 secondes puis l'affiche pendant (t-t0) secondes avant de recommencer r fois ce cycle en tout
Examples
afficherTempo(ob1)
// Affiche ob1 au bout de 1 seconde, pendant 4 secondes puis le masque. Ce cycle est répété indéfiniment.
afficherTempo(ob1,2,9,10)
// Sur un cycle de 9 secondes, affiche ob1 au bout de 2 seconde puis le masque en fin de cycle. Ce cycle est répété 10 fois.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
objet |
ObjetMathalea2D | Objet MathALEA2d masqué puis affiché |
||
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étitions (infini si ce n'est pas un nombre). |
afficherUnParUn(objets, topt, ropt, tApresDernieropt)
- Source:
Masque une suite d'objets puis les affiche un par un, de t secondes en t secondes avant de recommencer r fois, tApresDernier secondes après l'affichage de tous les objets
Examples
afficherUnParUn([s1,s2])
// Affiche s1 au bout de 1 seconde, puis s2 après 1 nouvelle seconde, puis les masque après 5 secondes. Ce cycle est répété indéfiniment.
afficherUnParUn([s1,s2],2,9,10)
// Affiche s1 au bout de 2 secondes, puis s2 après 2 nouvelles secondes, puis les masque après 10 secondes. Ce cycle est répété en tout 9 fois.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
objets |
Array.<ObjetMathalea2D> | Liste d'objets MathALEA2d masqués puis affichés |
||
t |
number |
<optional> |
1
|
Temps en secondes entre l'apparition de chaque objet |
r |
string |
<optional> |
'Infinity'
|
Nombre de répétitions (infini si ce n'est pas un nombre). |
tApresDernier |
number |
<optional> |
5
|
Temps, après l'affichage du dernier objet, à partir duquel l'animation recommence. |
affiniteOrtho(Objet, d, k, nomopt, positionLabelopt, coloropt) → {Point|Segment|Droite|Polygone|Vecteur}
Construit l'image d'un objet par affinité orthogonale
Examples
p2 = affiniteOrtho(p1,droite(B, C),k)
// p2 est l'image de p1 par une affinité orthogonale dont la direction est la droite (BC) et de rapport k
N = affiniteOrtho(M,d,0.5,'point N','right')
// N est l'image du point M par une affinité orthogonale de direction d et de rapport 0.5. Le point sera affiché comme "point N" et ce nom sera écrit à droite de sa position.
s = affiniteOrtho(segment(A, B),d,0.1,'','','red')
// s est l'image du segment [AB] par une affinité orthogonale de direction d et de rapport 0.1. s sera rouge.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
Objet |
Point | Segment | Droite | Polygone | Vecteur | Objet MathAlea2d choisi parmi un point, un segment, une droite, un polygone ou un vecteur |
||
d |
number | Direction de l'affinité |
||
k |
number | Rapport de l'affinité |
||
nom |
string |
<optional> |
''
|
Nom de l'image (uniquement valable pour un point) |
positionLabel |
string |
<optional> |
'above'
|
Position de l'image (uniquement valable pour un point) |
color |
string |
<optional> |
'black'
|
Couleur de la valeur indiquée : du type 'blue' ou du type '#f15929' (non valable pour un point et pour un vecteur) |
Returns:
Retourne un objet du même type que le paramètre objet de la fonction
aireTriangle(p) → {boolean|number}
Retourne l'aire du triangle si p est un triangle, false sinon.
Examples
aireTriangle(poygone(A,B,C)) // Retourne l'aire du triangle ABC
aireTriangle(poygone(A,B,C,D)) // Retourne false car le polygone n'est pas un triangle
Parameters:
Name | Type | Description |
---|---|---|
p |
Polygone | Triangle |
Returns:
- Type
- boolean | number
ajouterAx(x, lutin)
- Source:
Ajoute x à l'abscisse du lutin
Example
ajouterAx(10,lutin) // L'abscisse de lutin est augmentée de 10.
Parameters:
Name | Type | Description |
---|---|---|
x |
number | Valeur à ajouter à l'abscisse |
lutin |
ObjetLutin | Lutin |
ajouterAy(y, lutin)
- Source:
Ajoute y à l'ordonnée du lutin
Example
ajouterAy(10,lutin) // L'ordonnée de lutin est augmentée de 10.
Parameters:
Name | Type | Description |
---|---|---|
y |
number | Valeur à ajouter à l'ordonnée |
lutin |
ObjetLutin | Lutin |
allerA(x, y, lutin)
- Source:
Déplace le lutin de sa position courante à (x;y)
Example
allerA(10,-5,lutin) // Le lutin prend pour coordonnées (10 ; -5).
Parameters:
Name | Type | Description |
---|---|---|
x |
number | Nouvelle abscisse |
y |
number | Nouvelle ordonnée |
lutin |
ObjetLutin | Lutin |
angle(A, O, B, precisionopt) → {number}
Renvoie la mesure d'angle en degré
Examples
x = angle(H,E,T)
// x contient la mesure en degré de l'angle HET, arrondi au centième
x = angle(H,E,T,0)
// x contient la mesure en degré de l'angle HET, arrondi à l'unité
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point sur un côté de l'angle |
||
O |
Point | Sommet de l'angle |
||
B |
Point | Point sur l'autre côté de l'angle |
||
precision |
integer |
<optional> |
2
|
Nombre maximal de décimales de la valeur arrondie de la mesure de l'angle |
Returns:
- Type
- number
angleModulo(a) → {number}
Convertit un nombre de degrés quelconque en une mesure comprise entre -180 et 180
Examples
x = angleModulo(170)
// x contient 170
x = angleModulo(190)
// x contient -170
x = angleModulo(3690)
// x contient 90
x = angleModulo(180)
// x contient 180
x = angleModulo(-180)
// x contient 180
Parameters:
Name | Type | Description |
---|---|---|
a |
number | Valeur en degrés dont on cherche la valeur entre -180 et 180 |
Returns:
- Type
- number
angleOriente(A, O, B, precisionopt) → {number}
Retourne la valeur signée de la mesure d'un angle en degré
Examples
x = angleOriente(H,E,T)
// x contient la valeur de la mesure de l'angle orienté HET, arrondie au centième
x = angleOriente(H,E,T,0)
// x contient la valeur de la mesure de l'angle orienté HET, arrondie à l'unité
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point sur un côté de l'angle |
||
O |
Point | Sommet de l'angle |
||
B |
Point | Point sur l'autre côté de l'angle |
||
precision |
integer |
<optional> |
2
|
Nombre maximal de décimales de la valeur arrondie de la mesure de l'angle orienté |
Returns:
- Type
- number
angleradian(A, O, B, precisionopt) → {number}
Retourne la valeur la mesure d'un angle en radian
Examples
x = angleradian(H,E,T)
// x contient la valeur de la mesure de l'angle HET en radians, arrondie au centième
x = angleradian(H,E,T,0)
// x contient la valeur de la mesure de l'angle HET en radians, arrondie à l'unité
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point sur un côté de l'angle |
||
O |
Point | Sommet de l'angle |
||
B |
Point | Point sur l'autre côté de l'angle |
||
precision |
integer |
<optional> |
2
|
Nombre maximal de décimales de la valeur arrondie de la mesure de l'angle orienté |
Returns:
- Type
- number
angleScratchTo2d(x) → {angleModulo}
- Source:
Renvoie la mesure d'angle (entre -180° et 180°) dans le cercle trigonométrique à partir d'une mesure d'angle donnée en degrés, qu'utilise Scratch. Parce que le 0 angulaire de Scratch est dirigé vers le Nord et qu'il croît dans le sens indirect
Examples
x=angleScratchTo2d(0) // x=90
x=angleScratchTo2d(90) // x=0
x=angleScratchTo2d(-90) // x=180
x=angleScratchTo2d(-120) // x=-150
Parameters:
Name | Type | Description |
---|---|---|
x |
number | Angle Scratch |
Returns:
- Type
- angleModulo
ApparitionAnimee(liste, duropt, pourcentageopt, repeatopt)
- Source:
Fait apparaître une liste d'objets de façon animée.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
liste |
Array.<ObjetMathalea2D> | liste d'objets à faire apparaître |
||
dur |
number |
<optional> |
2
|
Durée de l'animation en secondes |
pourcentage |
number |
<optional> |
0.5
|
Pourcentage de la durée à partir de laquelle les objets sont visibles |
repeat |
number | string |
<optional> |
'indefinite'
|
Nombre de répétitions de l'animation, peut être un entier. |
apparitionAnimee(liste, duropt, pourcentageopt, repeatopt) → {ApparitionAnimee}
- Source:
Fait apparaître une liste d'objets de façon animée
Example
Fonction non utilisée donc pas d'exemple, fonction non testée, peut être bugguée
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
liste |
Array.<ObjetMathalea2D> | liste d'objets à faire apparaître |
||
dur |
number |
<optional> |
2
|
Durée de l'animation en secondes |
pourcentage |
number |
<optional> |
0.5
|
Pourcentage de la durée à partir de laquelle les objets sont visibles |
repeat |
number | string |
<optional> |
'indefinite'
|
Nombre de répétitions de l'animation, peut être un entier |
Returns:
- Type
- ApparitionAnimee
arc(M, Omega, angle, rayonopt, couleurDeRemplissageopt, coloropt, opaciteDeRemplissageopt, couleurDesHachuresopt) → {Arc}
Trace un arc de cercle, connaissant une extrémité, son centre et la mesure de l'angle
Examples
arc(M,O,35)
// Trace l'arc en noir de centre O, d'extrémité M et d'angle orienté 35° (sans remplissage et sans hachures)
arc(M,O,true,-40,'red','green',0.8,'white')
// Trace l'arc en vert de centre O, d'extrémité M et d'angle orienté -40°, rempli en rouge à 80 %, avec des hachures blanches
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
M |
Point | Extrémité de départ de l'arc |
||
Omega |
Point | Centre de l'arc |
||
angle |
number | Mesure de l'angle compris entre -360 et 360 (valeur négative = sens indirect) |
||
rayon |
boolean |
<optional> |
false
|
Booléen. Si true, les rayons délimitant l'arc sont ajoutés. |
couleurDeRemplissage |
string |
<optional> |
'none'
|
Couleur ou 'none' : du type 'blue' ou du type '#f15929' |
color |
string |
<optional> |
'black'
|
Couleur de l'arc ou 'none' : du type 'blue' ou du type '#f15929' |
opaciteDeRemplissage |
number |
<optional> |
0.2
|
Opacité de remplissage de 0 à 1. |
couleurDesHachures |
string |
<optional> |
'none'
|
Couleur des hachures ou 'none' : du type 'blue' ou du type '#f15929' Si 'none', pas de hachures. |
Returns:
- Type
- Arc
arcPointPointAngle(M, N, angle, rayonopt, couleurDeRemplissageopt, coloropt, opaciteDeRemplissageopt, couleurDesHachuresopt) → {Arc}
Trace un arc de cercle, connaissant deux extrémités et la mesure de l'angle
Examples
arcPointPointAngle(A,B,35)
// Trace l'arc en noir d'extrémités A et B (dans cet ordre) et d'angle orienté 35° (sans remplissage et sans hachures)
arcPointPointAngle(A,B,true,-40,'red','green',0.8,'white')
// Trace l'arc en vert d'extrémités A et B (dans cet ordre) et d'angle orienté -40°, rempli en rouge à 80 %, avec des hachures blanches
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
M |
Point | Première extrémité de l'arc |
||
N |
Point | Deuxième extrémité de l'arc |
||
angle |
number | Mesure de l'angle compris entre -360 et 360 (valeur négative = sens indirect) |
||
rayon |
boolean |
<optional> |
false
|
Booléen. Si true, les rayons délimitant l'arc sont ajoutés. |
couleurDeRemplissage |
boolean |
<optional> |
'none'
|
Couleur ou 'none' : du type 'blue' ou du type '#f15929' |
color |
string |
<optional> |
'black'
|
Couleur de l'arc ou 'none' : du type 'blue' ou du type '#f15929' |
opaciteDeRemplissage |
number |
<optional> |
0.2
|
Opacité de remplissage de 0 à 1. |
couleurDesHachures |
string |
<optional> |
'none'
|
Couleur des hachures ou 'none' : du type 'blue' ou du type '#f15929' Si 'none', pas de hachures. |
Returns:
- Type
- Arc
assombrirOuEclaircir(couleur, coefficient) → {string}
- Source:
Assombrit ou éclaircit une couleur
Examples
assombrirOuEclaircir('beige',20) renvoie une couleur beige plus claire.
assombrirOuEclaircir('f15929',-30) renvoie une couleur orange plus foncée.
Parameters:
Name | Type | Description |
---|---|---|
couleur |
string | Une couleur du type 'blue' ou du type '#f15929' |
coefficient |
number | Plus grand est un coefficient positif et plus on éclaircit. Plus petit est un coefficient négatif et plus on assombrit. |
Returns:
Retourne le code hexadecimal de la nouvelle couleur
- Type
- string
attendre(tempo, lutin)
- Source:
Fait "vibrer" le lutin, tempo fois autour de sa position courante
Example
attendre(5, lutin) // Fait "vibrer" 5 fois le lutin
Parameters:
Name | Type | Description |
---|---|---|
tempo |
number | Nombre de vibrations |
lutin |
ObjetLutin | Lutin |
avance(d, lutin)
- Source:
Fait avancer le lutin de d unités de lutin dans la direction de son orientation
Example
avance(5, lutin) // Fait avancer le lutin de 5 unités
Parameters:
Name | Type | Description |
---|---|---|
d |
number | Nombre d'unités choisi pour avancer |
lutin |
ObjetLutin | Lutin |
axes(xminopt, yminopt, xmaxopt, ymaxopt, thickopt, xstepopt, ystepopt, epaisseuropt, coloropt) → {Axes}
Trace un repère orthonormé
Examples
axes()
// Trace un repère orthonormé dont les axes des abscisses et des ordonnées ont pour minimum -30, maximum -30, épaisseur 2, avec un pas de 1 et de couleur noire. Le tiret de chaque graduation mesure 0,4.
axes(-10,-5,20,3,0.25,2,0.5,1,'red')
// Trace un repère orthonormé rouge dont les axes des abscisses et des ordonnées ont pour épaisseur 1 et dont le tiret de chaque graduation mesure 0,5.
// L'axe des abscisses va de -10 à 20 avec un pas de 2. L'axe des ordonnées va de -5 à 3 avec un pas de 0,5.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
xmin |
number |
<optional> |
-30
|
Valeur minimale sur l'axe des abscisses |
ymin |
number |
<optional> |
-30
|
Valeur minimale sur l'axe des ordonnées |
xmax |
number |
<optional> |
30
|
Valeur maximale sur l'axe des abscisses |
ymax |
number |
<optional> |
30
|
Valeur maximale sur l'axe des ordonnées |
thick |
number |
<optional> |
0.2
|
Demi-longueur des tirets de chaque graduation |
xstep |
number |
<optional> |
1
|
Pas sur l'axe des abscisses |
ystep |
number |
<optional> |
1
|
Pas sur l'axe des ordonnées |
epaisseur |
number |
<optional> |
2
|
Epaisseur des deux axes |
color |
string |
<optional> |
'black'
|
Couleur du codage : du type 'blue' ou du type '#f15929'. |
Returns:
- Type
- Axes
axeY(yminopt, ymaxopt, thickopt, ystepopt, epaisseuropt, coloropt, ytickopt, titreopt) → {AxeY}
Trace une droite verticale graduée
Examples
axeY()
// Trace un axe noir vertical gradué de -2 à 5, de 1 en 1, avec une petite graduation entre deux graduations principales (de longueur 0.2 et d'épaisseur 2), et sans titre
axeY(0,10,0.25,2,1,'red',5,'titre')
// Trace un axe rouge vertical gradué de 0 à 10, de 2 en 2, avec quatre petites graduations entre deux graduations principales (de longueur 0.25 et d'épaisseur 1), et avec comme titre de l'axe : titre
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
ymin |
number |
<optional> |
-2
|
Valeur minimale sur l'axe vertical |
ymax |
number |
<optional> |
5
|
Valeur maximale sur l'axe vertical |
thick |
number |
<optional> |
0.2
|
Largeur des tirets de chaque graduation principale |
ystep |
number |
<optional> |
1
|
Pas sur l'axe des ordonnées |
epaisseur |
number |
<optional> |
2
|
Epaisseur des deux axes |
color |
string |
<optional> |
'black'
|
Couleur du codage : du type 'blue' ou du type '#f15929'. |
ytick |
number |
<optional> |
2
|
Nombre de partage entre deux graduations principales |
titre |
string |
<optional> |
''
|
Titre de l'axe |
Returns:
- Type
- AxeY
baisseCrayon(lutin)
- Source:
Fait entrer le lutin dans le mode "trace"
Example
baisseCrayon(lutin) // Met lutin en mode "trace"
Parameters:
Name | Type | Description |
---|---|---|
lutin |
ObjetLutin |
barycentre(p, nomopt, positionLabelopt) → {Point}
Crée le barycentre d'un polygone
Examples
G = barycentre(pol) // Crée G, le barycentre du polygone pol, sans lui donner de nom
G = barycentre(pol,'G','below') // Crée G, le barycentre du polygone pol, en notant G sous le point, s'il est tracé et labellisé.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
p |
Polygone | Polygone dont on veut créer le barycentre |
||
nom |
string |
<optional> |
''
|
Nom du barycentre |
positionLabel |
string |
<optional> |
'above'
|
Position du nom par rapport au point |
Returns:
- Type
- Point
bissectrice(A, O, B, couleurBissectriceopt, coloropt, couleurConstructionopt, constructionopt, detailopt, markopt, tailleLosangeopt, epaisseurBissectriceopt, opaciteBissectriceopt, pointillesBissectriceopt) → {Bissectrice}
Trace la bissectrice d'un angle, en laissant éventuellement apparents les traits de construction au compas
Examples
bissectrice(N,R,J)
// Trace, en rouge, la bissectrice de l'angle NRJ, d'épaisseur 1 et d'opacité 100 %, sans autre option
bissectrice(N,R,J,'blue')
// Trace, en bleu, la bissectrice de l'angle NRJ, d'épaisseur 1 et d'opacité 100 %, sans autre option
bissectrice(N,R,J,'blue','red','green',true,true,'||',6,2,0.5,3)
// Trace, en rouge, la bissectrice de l'angle NRJ, d'épaisseur 1 et d'opacité 100 %. Les traits de construction sont dessinés en vert avec les marques '||' en rouge.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point sur un côté de l'angle |
||
O |
Point | Sommet de l'angle |
||
B |
Point | Point sur l'autre côté de l'angle |
||
couleurBissectrice |
string |
<optional> |
'red'
|
Couleur de la médiatrice : du type 'blue' ou du type '#f15929' Si 'none' ou '', pas de hachures. |
color |
string |
<optional> |
'blue'
|
Couleur du codage : du type 'blue' ou du type '#f15929'. |
couleurConstruction |
string |
<optional> |
'black'
|
Couleur de la médiatrice : du type 'blue' ou du type '#f15929' Si 'none' ou '', pas de hachures. |
construction |
boolean |
<optional> |
false
|
Si construction est true, alors on affiche le codage et aussi les coups de compas utiles à la construction. |
detail |
boolean |
<optional> |
false
|
Si detail est true, alors on affiche aussi en pointillés les rayons utiles à la construction. |
mark |
string |
<optional> |
'×'
|
Symbole posé sur les arcs |
tailleLosange |
number |
<optional> |
5
|
Longueur d'un côté du losange de construction |
epaisseurBissectrice |
number |
<optional> |
1
|
Epaisseur de la bissectrice |
opaciteBissectrice |
number |
<optional> |
1
|
Taux d'opacité de la bissectrice |
pointillesBissectrice |
number |
<optional> |
0
|
Si cette valeur est entre 1 et 5, la bissectrice est en pointillés |
Returns:
- Type
- Bissectrice
boite(Xminopt, Yminopt, Xmaxopt, Ymaxopt, coloropt, colorFillopt, opaciteDeRemplissageopt, texteIn, tailleTexteopt, texteColoropt, texteOpaciteopt, texteMaopt, echelleFigureopt) → {Boite}
Crée un rectangle positionné horizontal/vertical avec possibilité d'écrire du texte dedans
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
Xmin |
number |
<optional> |
0
|
abscisse du sommet en bas à gauche |
Ymin |
number |
<optional> |
0
|
ordonnée du sommet en bas à gauche |
Xmax |
number |
<optional> |
1
|
abscisse du sommet en haut à droite |
Ymax |
number |
<optional> |
1
|
ordonnée du sommet en haut à droite |
color |
string |
<optional> |
'black'
|
couleur du cadre |
colorFill |
string |
<optional> |
'none'
|
couleur de remplissage |
opaciteDeRemplissage |
number |
<optional> |
0.7
|
comme son nom l'indique utilisé si colorFill !== 'none' |
texteIn |
string | Texte à afficher (On peut passer du latex si texteIn commence et finit par $) |
||
tailleTexte |
number |
<optional> |
1
|
permet de modifier la taille du texteIn |
texteColor |
string |
<optional> |
'black'
|
permet de choisir la couleur du texteIn |
texteOpacite |
number |
<optional> |
0.7
|
indice d'opacité du texte de 0 à 1 |
texteMa |
boolean |
<optional> |
false
|
Si le texte n'est pas du latex, change la police pour mettre un style mathématique si true |
echelleFigure |
number |
<optional> |
1
|
permet de passer le scale utilisé dans la fonction mathalea2d afin d'adapter la taille du texte en latex |
Returns:
- Type
- Boite
cacherParDiv(id)
- Source:
Rend invisible un element d'après son id
Example
cacherParDiv(s2.id) // Cache l'objet s2
Parameters:
Name | Type | Description |
---|---|---|
id |
number | id propre à un objet MathALEA2d |
cacherTempo(objet, t0opt, topt, ropt)
- Source:
Affiche un objet pendant t0 secondes puis le cache pendant (t-t0) secondes avant de recommencer r fois ce cycle en tout
Examples
cacherTempo(figure1)
// Affiche figure1 pendant 1 seconde, puis le cache pendant 4 secondes et recommence ce cycle indéfiniment.
cacherTempo(figure1,2,8,3)
// Affiche figure1 pendant 2 secondes, puis le cache pendant 6 secondes et recommence ce cycle 3 fois en tout.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
objet |
ObjetMathalea2D | Objet MathALEA2d affiché puis masqué |
||
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étitions (infini si ce n'est pas un nombre) |
carre(A, B, coloropt) → {polygoneRegulier}
Trace un carré
Examples
carre(M,N)
// Trace le carré noir de sommets consécutifs M et N dans le sens direct
carre(N,M)
// Trace le carré noir de sommets consécutifs M et N dans le sens indirect
carre(M,N,'blue')
// Trace le carré bleu de sommets consécutifs M et N dans le sens direct
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Un sommet du carré |
||
B |
Point | Un sommet du carré, consécutif au précédent |
||
color |
string |
<optional> |
'black'
|
Couleur de l'arc ou 'none' : du type 'blue' ou du type '#f15929' |
Returns:
- Type
- polygoneRegulier
centreCercleCirconscrit(A, B, C, nomopt, positionLabelopt) → {Point}
Crée le centre du cercle circonscrit au triangle ABC
Examples
G = centreCercleCirconscrit(F,C,N)
// Crée G, le centre du cercle circonscrit au triangle FCN,sans être nommé.
G = centreCercleCirconscrit(F,C,N,'G','below')
// Crée G, le centre du cercle circonscrit au triangle FCN, en notant G sous le point, s'il est tracé et labellisé.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Premier sommet du triangle |
||
B |
Point | Deuxième sommet du triangle |
||
C |
Point | Troisième sommet du triangle |
||
nom |
string |
<optional> |
''
|
Nom du centre |
positionLabel |
string |
<optional> |
'above'
|
Position du nom par rapport au point |
Returns:
- Type
- Point
centreGraviteTriangle(A, B, C, nomopt, positionLabelopt) → {Point}
Crée le centre de gravité du triangle ABC
Examples
G = centreGraviteTriangle(F,C,N)
// Crée G, le centre de gravité du triangle FCN,sans être nommé.
G = centreGraviteTriangle(F,C,N,'G','below')
// Crée G, le centre de gravité du triangle FCN, en notant G sous le point, s'il est tracé et labellisé.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Premier sommet du triangle |
||
B |
Point | Deuxième sommet du triangle |
||
C |
Point | Troisième sommet du triangle |
||
nom |
string |
<optional> |
''
|
Nom du centre |
positionLabel |
string |
<optional> |
'above'
|
Position du nom par rapport au point |
Returns:
- Type
- Point
cercle(O, r, coloropt, couleurDeRemplissageopt, couleurDesHachuresopt, epaisseuropt, pointillesopt, opaciteopt, opaciteDeRemplissageopt, epaisseurDesHachuresopt, distanceDesHachuresopt) → {Cercle}
Construit le cercle (ou le disque) de centre O, de rayon r
Examples
cercle (A,5)
// Construit un cercle c1 noir de centre A et de rayon 5
cercle (A,5,'red','blue','#f15929',3,2,0.3,0.8)
// Construit un disque de centre A et de rayon 5, de bord rouge à 30 % d'opacité et en pointillés, rempli en bleu à 80 % d'opacité, et avec des hachures orange de 1 d'épaisseur et avec 10 d'écart entre deux hachures
cercle (A,5,'red','blue','#f15929',3,2,0.3,0.8,2,12)
// Construit un disque de centre A et de rayon 5, de bord rouge à 30 % d'opacité et en pointillés, rempli en bleu à 80 % d'opacité, et avec des hachures orange de 2 d'épaisseur et avec 12 d'écart entre deux hachures
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
O |
Point | Centre du cercle |
||
r |
number | Rayon du cercle |
||
color |
string |
<optional> |
'black'
|
Couleur du cercle ou 'none' : du type 'blue' ou du type '#f15929' |
couleurDeRemplissage |
string |
<optional> |
'none'
|
Couleur de remplissage ou 'none' : du type 'blue' ou du type '#f15929' |
couleurDesHachures |
string |
<optional> |
'none'
|
Couleur des hachures ou 'none' : du type 'blue' ou du type '#f15929' Si 'none' ou '', pas de hachures. |
epaisseur |
number |
<optional> |
1
|
Epaisseur du cercle |
pointilles |
number |
<optional> |
0
|
Style des pointillés du cercle (entier entre 1 et 5). Si autre chose, pas de pointillés. |
opacite |
number |
<optional> |
1
|
Opacité du cercle |
opaciteDeRemplissage |
number |
<optional> |
1.1
|
Opacité du disque si couleur de remplissage choisie. |
epaisseurDesHachures |
number |
<optional> |
1
|
Epaisseur des hachures si couleur de hachures choisie. |
distanceDesHachures |
number |
<optional> |
10
|
Distance des hachures si couleur de remplissage choisie. |
Returns:
- Type
- Cercle
cercleCentrePoint(O, M, coloropt, couleurDeRemplissageopt, couleurDesHachuresopt, epaisseuropt, pointillesopt, opaciteopt, opaciteDeRemplissageopt, epaisseurDesHachuresopt, distanceDesHachuresopt) → {Cercle}
Construit le cercle (ou le disque) de centre O, passant par M
Examples
cercleCentrePoint (A,B)
// Construit un cercle c1 noir de centre A, passant par B
cercleCentrePoint (A,B,'red','blue','#f15929',3,2,0.3,0.8)
// Construit un disque de centre A, passant par B, de bord rouge à 30 % d'opacité et en pointillés, rempli en bleu à 80 % d'opacité, et avec des hachures orange de 1 d'épaisseur et avec 10 d'écart entre deux hachures
cercleCentrePoint (A,B,'red','blue','#f15929',3,2,0.3,0.8,2,12)
// Construit un disque de centre A, passant par B, de bord rouge à 30 % d'opacité et en pointillés, rempli en bleu à 80 % d'opacité, et avec des hachures orange de 2 d'épaisseur et avec 12 d'écart entre deux hachures
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
O |
Point | Centre du cercle |
||
M |
number | Point du cercle |
||
color |
string |
<optional> |
'black'
|
Couleur du cercle ou 'none' : du type 'blue' ou du type '#f15929' |
couleurDeRemplissage |
string |
<optional> |
'none'
|
Couleur de remplissage ou 'none' : du type 'blue' ou du type '#f15929' |
couleurDesHachures |
string |
<optional> |
'none'
|
Couleur des hachures ou 'none' : du type 'blue' ou du type '#f15929' Si 'none' ou '', pas de hachures. |
epaisseur |
number |
<optional> |
1
|
Epaisseur du cercle |
pointilles |
number |
<optional> |
0
|
Style des pointillés du cercle (entier entre 1 et 5). Si autre chose, pas de pointillés. |
opacite |
number |
<optional> |
1
|
Opacité du cercle |
opaciteDeRemplissage |
number |
<optional> |
1.1
|
Opacité du disque si couleur de remplissage choisie. |
epaisseurDesHachures |
number |
<optional> |
1
|
Epaisseur des hachures si couleur de hachures choisie. |
distanceDesHachures |
number |
<optional> |
10
|
Distance des hachures si couleur de remplissage choisie. |
Returns:
- Type
- Cercle
cercleTrigo(angle, cosOrSin)
Parameters:
Name | Type | Description |
---|---|---|
angle |
Angle | |
cosOrSin |
string |
Returns:
string
cibleCarree(xopt, yopt, rangopt, numopt, tailleopt, coloropt, opaciteopt) → {CibleCarree}
Crée une cible carrée pour l'auto-correction
Examples
cibleCarree({})
// Crée une cible Carree, de centre (0,0), avec 4 carrés en largeur dont chacune a pour côté 0.6, de couleur grise avec une opacité de 50 %
cibleCarree({ x: 2, y: -1, rang: 5, num: 17, taille: 0.5, color: 'blue', opacite: 0.8 })
// Crée une cible Carree, de centre (2,-1), avec 5 carrés en largeur dont chacune a pour côté 0.5, de couleur bleue avec une opacité de 80 %, portant le numéro 17
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
x |
number |
<optional> |
0
|
Abscisse du point au centre de la cible |
y |
number |
<optional> |
0
|
Ordonnée du point au centre de la cible |
rang |
number |
<optional> |
4
|
Nombre de cases en largeur |
num |
number |
<optional> |
Numéro (ou rien) pour identifier la cible (quand il y en a plusieurs) |
|
taille |
number |
<optional> |
0.6
|
Taille des cases |
color |
string |
<optional> |
'gray'
|
Couleur de la cible. Code couleur HTML acceptée |
opacite |
number |
<optional> |
0.5
|
Opacité de la cible |
Returns:
- Type
- CibleCarree
cibleCouronne(xopt, yopt, tailleopt, taille2opt, departopt, nbDivisionsopt, nbSubDivisionsopt, semiopt, labelopt, coloropt, opaciteopt) → {CibleCouronne}
Crée une cible couronne pour l'auto-correction
Examples
cibleCouronne({})
// Crée une cible couronne circulaire, de centre (0,0), dont le rayon du cercle intérieur est 5, la longueur des segments est 1, la première lettre démarre à 0°,
// le nombre de divisions de la couronne est 18, le nombre de subdivisions est 3, leur opacité est 50 %, avec les lettres apparentes, de couleur grise
cibleCouronne({ x: 2, y: -1, taille: 4, taille2: 2, depart: 35, nbDivisions: 12, nbSubDivisions: 2, semi: true, label: false, color: 'blue', opacite: 0.8 })
// Crée une cible couronne semi-circulaire, de centre (2,-1), dont le rayon du cercle intérieur est 4, la longueur des segments est 2, la première lettre démarre à 35°,
// le nombre de divisions de la couronne est 12, le nombre de subdivisions est 2, leur opacité est 80 %, avec les lettres non apparentes, de couleur bleue
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
x |
number |
<optional> |
0
|
Abscisse du point au centre de la cible |
y |
number |
<optional> |
0
|
Ordonnée du point au centre de la cible |
taille |
number |
<optional> |
5
|
Rayon du cercle intérieur |
taille2 |
number |
<optional> |
1
|
Longueur des segments dans la couronne |
depart |
number |
<optional> |
0
|
Valeur angulaire en degré du départ de la couronne |
nbDivisions |
number |
<optional> |
18
|
Nombre de divisions de la couronne |
nbSubDivisions |
number |
<optional> |
3
|
Nombre de subdivisions dans chaque division de la couronne |
semi |
boolean |
<optional> |
false
|
Pour obtenir une cible semi-circulaire ou circulaire |
label |
boolean |
<optional> |
true
|
Pour faire apparaître ou disparaître les lettres dans la couronne |
color |
string |
<optional> |
'gray'
|
Couleur de la cible. Code couleur HTML acceptée |
opacite |
number |
<optional> |
0.5
|
Opacité des segments de divisions et subdivisions |
Returns:
- Type
- CibleCouronne
cibleRonde(xopt, yopt, rangopt, tailleopt, coloropt, opaciteopt) → {CibleRonde}
Crée une cible ronde pour l'auto-correction
Examples
cibleRonde({})
// Crée une cible ronde, de centre (0,0), possédant 3 cercles, avec une distance de 0,3 entre chaque cercle consécutifu cercle intérieur est 5, de couleur grise avec une opacité de 50 %.
cibleRonde({ x: 2, y: -1, rang: 10, taille: 1, color: 'blue', opacite: 0.8 })
// Crée une cible ronde, de centre (2,-1), possédant 10 cercles, avec une distance de 1 entre chaque cercle consécutifu cercle intérieur est 5, de couleur bleue avec une opacité de 80 %.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
x |
number |
<optional> |
0
|
Abscisse du point au centre de la cible |
y |
number |
<optional> |
0
|
Ordonnée du point au centre de la cible |
rang |
number |
<optional> |
3
|
Nombre de cercles centrés sur le centre de la cible |
taille |
number |
<optional> |
0.3
|
Distance entre le centre de la cible et le premier cercle (et entre chaque cercle consécutif) |
color |
string |
<optional> |
'gray'
|
Couleur de la cible. Code couleur HTML acceptée |
opacite |
number |
<optional> |
0.5
|
Opacité de la cible |
Returns:
- Type
- CibleRonde
clone(originalObject) → {object}
- 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.
- Type
- object
codageAngle(A, O, angle, tailleopt, markopt, coloropt, epaisseuropt, opaciteopt, couleurDeRemplissageopt, opaciteDeRemplissageopt, mesureOnopt, noAngleDroitopt, texteACoteopt, tailleTexteopt) → {CodageAngle|CodageAngleDroit}
Code un angle
Examples
codageAngle(H,K,30)
// Code l'angle de centre K, avec H sur un côté de l'angle et avec 30° comme mesure d'angle orienté,
// en noir, avec une épaisseur de 1, une opacité de 100 %, un rayon d'arc de 0,8, sans autre option.
codageAngle(H,K,G)
// Code l'angle HKG, en noir, avec une épaisseur de 1, une opacité de 100 %, un rayon d'arc de 0,8, sans autre option.
codageAngle(H,K,G,2,'x','red',0.5,0.2,'blue',0.8,true,true)
// Code l'angle HKG, en rouge, avec une épaisseur de 0.5 et une opacité de 20 %, rempli en bleu avec une opacité de 80 %
// avec un arc de cercle de rayon 2, avec une marque 'x' sur l'angle, en affichant la mesure de l'angle et sans faire apparaître d'angle droit le cas échéant.
codageAngle(H,K,G,2,'x','red',0.5,0.2,'blue',0.8,true,true,'?',2)
// Code l'angle HKG, en rouge, avec une épaisseur de 0.5 et une opacité de 20 %, rempli en bleu avec une opacité de 80 %
// avec un arc de cercle de rayon 2, avec une marque 'x' sur l'angle, en affichant le texte '?' d'une taille de 2 et sans faire apparaître d'angle droit le cas échéant.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point sur un côté de l'angle |
||
O |
Point | Sommet de l'angle |
||
angle |
number | Point | Mesure de l'angle ou nom d'un point sur l'autre côté de l'angle |
||
taille |
number |
<optional> |
0.8
|
Taille de l'angle |
mark |
string |
<optional> |
''
|
Marque sur l'angle |
color |
string |
<optional> |
'black'
|
Couleur de l'angle : du type 'blue' ou du type '#f15929' |
epaisseur |
number |
<optional> |
1
|
Epaisseur du tracé de l'angle |
opacite |
number |
<optional> |
1
|
Opacité de la couleur du tracé de l'angle |
couleurDeRemplissage |
string |
<optional> |
'none'
|
'none' si on ne veut pas de remplissage, sinon une couleur du type 'blue' ou du type '#f15929' |
opaciteDeRemplissage |
number |
<optional> |
0.2
|
Opacité de la couleur de remplissage de l'angle |
mesureOn |
boolean |
<optional> |
false
|
Affichage de la mesure de l'angle |
noAngleDroit |
boolean |
<optional> |
false
|
Pour choisir si on veut que l'angle droit soit marqué par un carré ou pas |
texteACote |
string |
<optional> |
''
|
Pour mettre un texte à côté de l'angle à la place de la mesure de l'angle |
tailleTexte |
number |
<optional> |
1
|
Pour choisir la taille du texte à côté de l'angle |
Returns:
- Type
- CodageAngle | CodageAngleDroit
codageAngleDroit(A, O, B, coloropt, dopt, epaisseuropt, opaciteopt, couleurDeRemplissageopt, opaciteDeRemplissageopt) → {CodageAngleDroit}
Code un angle droit
Examples
codageAngleDroit(A,J,T)
// Trace un codage d'angle droit pour l'angle direct AJT, de couleur noire, de taille 0,4, d'épaisseur 0,5 avec une opacité de 100 %, sans remplissage
codageAngleDroit(A,J,T,'pink',1,0.2,0.6,'blue',0.2)
// Trace un codage d'angle droit pour l'angle direct AJT, de couleur rose, de taille 1, d'épaisseur 0,2 avec une opacité de 60 %, rempli en bleu avec une opacité de 20%.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point sur un côté de l'angle droit |
||
O |
Point | Sommet de l'angle droit |
||
B |
Point | Point sur l'autre côté de l'angle droit |
||
color |
string |
<optional> |
'black'
|
Couleur du codage : du type 'blue' ou du type '#f15929' |
d |
number |
<optional> |
0.4
|
Taille du codage de l'angle droit |
epaisseur |
number |
<optional> |
0.5
|
Epaisseur du trait |
opacite |
number |
<optional> |
1
|
Opacité du trait |
couleurDeRemplissage |
string |
<optional> |
'none'
|
'none' si on ne veut pas de remplissage, sinon une couleur du type 'blue' ou du type '#f15929' |
opaciteDeRemplissage |
number |
<optional> |
1
|
Taux d'opacité du remplissage |
Returns:
- Type
- CodageAngleDroit
codageBissectrice(A, O, B, coloropt, markopt) → {CodageBissectrice}
Code la bissectrice d'un angle
Examples
codagebissectrice(M,N,P) // Code, en noir, la bissectrice de l'angle MNP avec les marques 'x'
codagebissectrice(M,N,P,'red','oo') // Code, en rouge, la bissectrice de l'angle MNP avec les marques 'oo'
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point sur un côté de l'angle |
||
O |
Point | Sommet de l'angle |
||
B |
Point | Point sur l'autre côté de l'angle |
||
color |
string |
<optional> |
'black'
|
Couleur de la bissectrice : du type 'blue' ou du type '#f15929' |
mark |
string |
<optional> |
'x'
|
Symbole posé sur les arcs |
Returns:
- Type
- CodageBissectrice
codageCarre(c, coloropt, markopt) → {CodageCarre}
Properties:
Name | Type | Description |
---|---|---|
svg |
string | Sortie au format vectoriel (SVG) que l’on peut afficher dans un navigateur |
tikz |
string | Sortie au format TikZ que l’on peut utiliser dans un fichier LaTeX |
Met un codage complet sur un carré
Examples
codageCarre(carre) // Code, en noir, le carré carre.
codageCarre(carre,'red','||') // Code, en rouge, le carré carre avec la marque || sur les côtés
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
c |
Polygone | Carré à coder |
||
color |
string |
<optional> |
'black'
|
Couleur des codages : du type 'blue' ou du type '#f15929' |
mark |
string |
<optional> |
'x'
|
Symbole posé sur les côtés |
Returns:
- Type
- CodageCarre
codageHauteurTriangle(A, B, C, coloropt) → {CodageHauteurTriangle}
Code la hauteur d'un triangle
Examples
codageHauteurTriangle(M,N,P) // Code, en noir, la hauteur du triangle MNP.
codageHauteurTriangle(M,N,P,'red') // Code, en rouge, la hauteur du triangle MNP.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Premier sommet d'un triangle |
||
B |
Point | Deuxième sommet d'un triangle |
||
C |
Point | Troisième sommet d'un triangle |
||
color |
string |
<optional> |
'black'
|
Couleur des codages : du type 'blue' ou du type '#f15929' |
Returns:
codageMedianeTriangle(B, C, coloropt, markopt, milopt) → {CodageSegments}
Code la médiane d'un triangle
Examples
codageMedianeTriangle(M,N) // Code, en noir, la médiane d'un triangle relative au côté [MN], avec les symboles //
codageMedianeTriangle(M,N,P,'red','oo') // Code, en rouge, la médiane d'un triangle relative au côté [MN], avec les symboles oo
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
B |
Point | Première extrémité du segment dont la médiane est relative |
||
C |
Point | Seconde extrémité du segment dont la médiane est relative |
||
color |
string |
<optional> |
'black'
|
Couleur des codages : du type 'blue' ou du type '#f15929' |
mark |
string |
<optional> |
'//'
|
Symbole posé de part et d'autre du milieu du segment |
mil |
boolean |
<optional> |
false
|
Trace ou nom le point du milieu. |
Returns:
- Type
- CodageSegments
codageMediatrice(A, B, coloropt, markopt) → {CodageMediatrice}
Code la médiatrice d'un segment
Examples
codageMediatrice(M,N) // Code, en noir, la médiatrice du segment[MN] avec les marques 'x'
codageMediatrice(M,N,'red','oo') // Code, en rouge, la médiatrice du segment[MN] avec les marques 'oo'
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Première extrémité du segment |
||
B |
Point | Seconde extrémité du segment |
||
color |
string |
<optional> |
'black'
|
Couleur du codage : du type 'blue' ou du type '#f15929'. |
mark |
string |
<optional> |
'x'
|
Symbole posé sur les deux parties du segment |
Returns:
- Type
- CodageMediatrice
codageMilieu(A, B, coloropt, markopt, milopt) → {CodageMilieu}
Code le milieu d'un segment
Examples
codageMilieu(M,N) // Code, en noir, le milieu du segment[MN] avec les marques 'x', en plaçant le milieu
codageMilieu(M,N,'red','oo',false) // Code, en rouge, le milieu du segment[MN] avec les marques 'oo', sans placer le milieu.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Première extrémité du segment |
||
B |
Point | Seconde extrémité du segment |
||
color |
string |
<optional> |
'black'
|
Couleur du codage : du type 'blue' ou du type '#f15929'. |
mark |
string |
<optional> |
'x'
|
Symbole posé de part et d'autre du milieu du segment |
mil |
boolean |
<optional> |
true
|
Trace ou nom le point du milieu. |
Returns:
- Type
- CodageMilieu
codageSegment(A, B, markopt, coloropt) → {TexteParPoint}
Code un segment
Examples
codageSegment(H,K) // Code le segment [HK] avec la marque noire '||'
codageAngle(H,K,'x','green') // Code le segment [HK] avec la marque verte 'x'
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 : du type 'blue' ou du type '#f15929' |
Returns:
- Type
- TexteParPoint
codageSegments(markopt, coloropt, args) → {CodageSegments}
Code plusieurs segments de la même façon
Examples
codageSegments('×','blue',A,B, B,C, C,D) // Code les segments [AB], [BC] et [CD] avec une croix bleue
codageSegments('×','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)
codageSegments('×','blue',s1,s2,s3) // Code les segments s1, s2 et s3 avec une croix bleue
codageSegments('×','blue',p.listePoints) // Code tous les segments du polygone avec une croix bleue
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
mark |
string |
<optional> |
'||'
|
Symbole posé sur le segment |
color |
string |
<optional> |
'black'
|
Couleur du symbole : : du type 'blue' ou du type '#f15929' |
args |
Points | Array.<Point> | Segments | Les segments différement codés. Voir exemples. |
Returns:
- Type
- CodageSegments
colorToLatexOrHTML(couleur) → {Array.<string>}
- Source:
colorToLatexOrHTML prend en paramètre une couleur sous forme prédéfinie ('red','yellow',...) ou sous forme HTML en hexadécimal (avec #, genre '#f15929') La sortie de cette fonction est un tableau où :
- le premier élément est cette couleur exploitable en SVG, donc en HTML.
- le second élément est cette couleur exploitable en TikZ, donc en Latex.
Examples
colorToLatexOrHTML('red')=['red','{red}']
colorToLatexOrHTML('#f15929')=['#f15929','{rgb,255:red,241;green,89;blue,41}']
colorToLatexOrHTML('')=''
colorToLatexOrHTML('none')=['none','none']
Parameters:
Name | Type | Description |
---|---|---|
couleur |
string | Une couleur du type 'blue' ou du type '#f15929' |
Returns:
- Type
- Array.<string>
convertCodeCouleurToHex(color)
- Source:
Convertit un code couleur en sa valeur hexadecimale
Example
convertCodeCouleurToHex('beige')='#f5f5dc'
Parameters:
Name | Type | Description |
---|---|---|
color |
string | Une couleur du type 'blue' et uniquement de ce type |
Returns:
convertHexToRGB(Couleuropt) → {Array.<number>}
- Source:
convertHexToRGB convertit une couleur en héxadécimal (sans le #) en un tableau RVB avec des valeurs entre 0 et 255.
Example
convertHexToRGB('f15929')=[241,89,41]
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
Couleur |
string |
<optional> |
'000000'
|
Code couleur HTML sans le # |
Returns:
- Type
- Array.<number>
courbe(f, parametres) → {Courbe}
Trace la courbe d'une fonction dans un repère
Examples
courbe(g, {repere: r})
// Trace, en noir avec une épaisseur de 2, la courbe g dans le repère r, tous deux précédemment définis.
courbe(g, {repere: r, epaisseur: 5, color: 'blue'})
// Trace la courbe g dans le repère r, tous deux précédemment définis, en bleu, avec une épaisseur de 5.
Parameters:
Name | Type | Description | |||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f |
function | Fonction à tracer comme par exemple : const f = x => a * x ** 2 + b * x + c |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- Courbe
courbeInterpolee(tableau, parametres) → {CourbeInterpolee}
Trace la courbe d'une fonction interpolée, linéaire par parties, dans un repère
Examples
courbeInterpolee(tab, {repere: r})
// Trace, en noir avec une épaisseur de 2, la courbe de la fonction interpolée sur les intervalles définis dans tab, dans le repère r, tous deux précédemment définis.
courbeInterpolee(tab, {repere: r, epaisseur: 5, color: 'blue'})
// Trace la courbe de la fonction interpolée sur les intervalles définis dans tab, dans le repère r, tous deux précédemment définis, en bleu avec une épaisseur de 5.
Parameters:
Name | Type | Description | ||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
tableau |
Array.<Array.number> | Ce tableau de tableaux contient les coordonnées des points à rejoindre comme par exemple : [[-5,2],[-1,-7],[2,5],[3,-1]] |
||||||||||||||||||||||||||||||
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- CourbeInterpolee
courbeSpline(f, parametres) → {CourbeSpline}
Trace la courbe d'une fonction, précédemment définie comme Spline, dans un repère
Examples
courbeSpline(g, {repere: r})
// Trace, en noir avec une épaisseur de 2, la courbe spline g dans le repère r, tous deux précédemment définis.
courbeSpline(g, {repere: r, epaisseur: 5, color: 'blue'})
// Trace la courbe spline g dans le repère r, tous deux précédemment définis, en bleu, avec une épaisseur de 5.
Parameters:
Name | Type | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f |
function | fonction à tracer défine, au préalable, avec splineCatmullRom() |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- CourbeSpline
creerLutin(…args) → {object}
- 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
- Type
- object
dansLaCibleCarree(x, y, rang, taille, cellule) → {Array.<number>|string}
Retourne un couple de coordonnées correspondant au centre d'une cible, connaissant les coordonnées du point réponse et de la cellule dans laquelle on veut qu'il soit
Example
dansLaCibleCarree(-1, -3, 4, 0.6, 'B2')
// Retourne les coordonnées du centre d'une cible carrée de rang 4 et de taille 0.6 dont la réponse est le point (-1;-3) dans la cellule B2
Parameters:
Name | Type | Description |
---|---|---|
x |
number | Abscisse du point réponse |
y |
number | Ordonnée du point réponse |
rang |
number | Nombre de cases en largeur |
taille |
number | Taille des cases |
cellule |
string | Cellule de la réponse, chaine définie par exemple comme 'A1' ou 'B3' |
Returns:
Ce sont les coordonnées du centre de la cible ou bien 'Cette cellule n'existe pas dans la cible'
- Type
- Array.<number> | string
dansLaCibleRonde(x, y, rang, taille, cellule) → {Array.<number>|string}
Retourne un couple de coordonnées correspondant au centre d'une cible, connaissant les coordonnées du point réponse et de la cellule dans laquelle on veut qu'il soit
Example
dansLaCibleCarree(-1, -3, 4, 0.6, 'B2')
// Retourne les coordonnées du centre d'une cible ronde de rang 4 et de taille 0.6 dont la réponse est le point (-1;-3) dans la cellule B2
Parameters:
Name | Type | Description |
---|---|---|
x |
number | Abscisse du point réponse |
y |
number | Ordonnée du point réponse |
rang |
number | Nombre de cases sur une couronne |
taille |
number | Différence entre deux rayons successifs |
cellule |
string | Cellule de la réponse, chaine définie par exemple comme 'A1' ou 'B3' |
Returns:
Ce sont les coordonnées du centre de la cible ou bien 'Cette cellule n'existe pas dans la cible'
- Type
- Array.<number> | string
demiDroite(A, B, coloropt, extremitesopt) → {DemiDroite}
Trace la demi-droite d'origine A passant par B
Examples
demiDroite(M, N) // Trace la demi-droite d'origine M passant par N et de couleur noire
demiDroite(M, N, 'blue', true) // Trace la demi-droite d'origine M passant par N et de couleur bleue, en traçant le trait signifiant l'origine de la demi-droite
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
color |
string |
<optional> |
'black'
|
Facultatif, 'black' par défaut |
extremites |
boolean |
<optional> |
false
|
Trace (ou pas) l'origine de la demi-droite |
Returns:
- Type
- DemiDroite
deplaceLabel(p, nom, positionLabel)
Déplace les labels des sommets d'un polygone s'ils sont mal placés nativement
Example
deplaceLabel(p1,'MNP','below') // S'il y a des points nommés 'M', 'N' ou 'P' dans le polygone p1, leur nom sera mis en dessous du point.
// Ne fonctionne pas avec les points du type A1 ou A_1.
Parameters:
Name | Type | Description |
---|---|---|
p |
Polygone | Polygone sur lequel les labels de ses sommets sont mal placés |
nom |
string | Points mal placés sous la forme, par exemple, 'AB'. Chaque point doit être représenté par un SEUL caractère. |
positionLabel |
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'. |
dessousDessus(d, A, toleranceopt) → {'sur'|'droite'|'gauche'|'dessous'|'dessus'}
Donne la position du point A par rapport à la droite d
Examples
dessousDessus(d1, M) // Renvoie la position de M par rapport à d1 parmi ces 5 possibilités : 'sur', 'droite', 'gauche', 'dessous', 'dessus'
dessousDessus(d1, M, 0.005) // Renvoie la position de M par rapport à d1 parmi ces 5 possibilités : 'sur', 'droite', 'gauche', 'dessous', 'dessus' (avec une tolérance de 0,005)
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
d |
Droite | |||
A |
Point | |||
tolerance |
number |
<optional> |
0.0001
|
Seuil de tolérance pour évaluer la proximité entre d et A. |
Returns:
- Type
- 'sur' | 'droite' | 'gauche' | 'dessous' | 'dessus'
diagrammeBarres(hauteursBarres, etiquettes, parametres) → {DiagrammeBarres}
Trace un diagramme en barres
Examples
diagrammeBarres([15, 25, 30, 10, 20], ['Compas', 'Rapporteur', 'Règle', 'Crayon', 'Gomme'])
// Trace un diagramme en barres avec les options par défaut
diagrammeBarres([15, 25, 30, 10, 20], ['Compas', 'Rapporteur', 'Règle', 'Crayon', 'Gomme'],{
reperageTraitPointille: true, couleurDeRemplissage: 'red', titreAxeVertical: 'Nombre de réponses',
titre = 'Matériel mathématique dans sa trousse', * hauteurDiagramme: 10, coeff: 3, etiquetteValeur: false }})
// Trace un diagramme en barres avec modification de quelques options par défaut
Parameters:
Name | Type | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
hauteursBarres |
Array.<number> | Tableau des effectifs |
||||||||||||||||||||||||||||||||||||||||||||||||||
etiquettes |
Array.<string> | Tableau des labels pour chaque effectif |
||||||||||||||||||||||||||||||||||||||||||||||||||
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- DiagrammeBarres
diagrammeCirculaire(parametres) → {DiagrammeCirculaire}
Trace un diagramme circulaire
Example
diagrammeCirculaire({ rayon: 7, semi: false, legendePosition: 'dessous',
effectifs: [15, 25, 30, 10, 20],
labels: ['Compas', 'Rapporteur', 'Règle', 'Crayon', 'Gomme'],
mesures: [true, true, true, false, true],
visibles: [true, false, true, true, true],
pourcents: [true, true, true, false, true],
valeurs: [true, false, true, true, false],
hachures: [true, true, true, false, true],
remplissage: [false, true, true, true, true] })
// Trace un diagramme semi-circulaire de rayon 7 avec différentes options
Parameters:
Name | Type | Description | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- DiagrammeCirculaire
distancePointDroite(A, d) → {longueur}
Donne la distance entre le point A et la droite d
Example
distancePointDroite (M, d1) // Retourne la distance entre le point M et la droite d1
Parameters:
Name | Type | Description |
---|---|---|
A |
point | |
d |
droite |
Returns:
- Type
- longueur
droite(arg1, arg2, arg3, arg4, arg5) → {Droite}
Trace une droite définie par 2 points OU BIEN par les coefficients de son équation
Examples
droite(M, N, '(d1)') // Trace la droite passant par M et N se nommant (d1) et de couleur noire
droite(M, N, '(d1)','blue') // Trace la droite passant par M et N se nommant (d1) et de couleur bleue
droite(m, n, p) // Trace la droite définie par les coefficients de mx+ny+p=0 et de couleur noire
droite(m, n, p, '(d1)', 'red') // Trace la droite définie par les coefficients de mx+ny+p=0, se nommant (d1) et de couleur rouge
Parameters:
Name | Type | Description |
---|---|---|
arg1 |
Point | number | Premier point de la droite OU BIEN coefficient a de l'équation de la droite ax+by+c=0 avec (a,b)!=(0,0) |
arg2 |
Point | number | Deuxième point de la droite OU BIEN coefficient b de l'équation de la droite ax+by+c=0 avec (a,b)!=(0,0) |
arg3 |
string | number | Nom affichée de la droite OU BIEN coefficient c de l'équation de la droite ax+by+c=0 |
arg4 |
string | Couleur de la droite : du type 'blue' ou du type '#f15929' OU BIEN nom affichée de la droite si arg1 est un nombre |
arg5 |
string | Couleur de la droite : du type 'blue' ou du type '#f15929' si arg1 est un nombre |
Returns:
- Type
- Droite
droiteGraduee(parametres) → {DroiteGraduee}
Trace un axe gradué
Example
droiteGraduee({
x: 0,
y: 3,
Min: -2.7,
Max: 12 + 0.2,
thickSec: true,
Unite: 3,
thickCouleur: 'red',
axeCouleur: 'blue',
axeHauteur: 4,
labelsPrincipaux: false,
labelListe: [[0, 'O'], [1, 'I']],
pointListe: [[-1, 'A'], [5, 'B'], [7.2, 'C']],
pointTaille: 6,
pointCouleur: 'gray',
pointStyle: '|',
pointEpaisseur: 3
})
// Trace une droite graduée avec différentes options
Parameters:
Name | Type | Description | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- DroiteGraduee
droiteHorizontaleParPoint(A, nomopt, coloropt) → {droiteParPointEtPente}
Trace la droite horizontale passant par le point A
Examples
droiteHorizontaleParPoint(M) // Trace la droite horizontale passant par le point M
droiteHorizontaleParPoint(M, 'd1', 'red') // Trace, en rouge, la droite horizontale d1 passant par le point M
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point de la droite |
||
nom |
string |
<optional> |
''
|
Nom affichée de la droite |
color |
string |
<optional> |
'black'
|
Couleur de la droite : du type 'blue' ou du type '#f15929' |
Returns:
droiteParPointEtParallele(A, d, nomopt, coloropt) → {droiteParPointEtVecteur}
Trace la droite parallèle à d passant par le point A
Examples
droiteParPointEtParallele(M, d2) // Trace la droite parallèle à d2 passant par le point M
droiteParPointEtParallele(M, d2, 'd1', 'red') // Trace, en rouge, la droite d1 parallèle à d2 passant par le point M
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point de la droite |
||
d |
Droite | Droite |
||
nom |
string |
<optional> |
''
|
Nom affichée de la droite |
color |
string |
<optional> |
'black'
|
Couleur de la droite : du type 'blue' ou du type '#f15929' |
Returns:
droiteParPointEtPente(A, k, nomopt, coloropt) → {Droite}
Trace la droite passant par le point A et de pente k
Examples
droiteParPointEtPente(M, p) // Trace la droite passant par le point M et de pente p
droiteParPointEtPente(M, p, 'd1', 'red') // Trace, en rouge, la droite d1 passant par le point M et de pente p
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point de la droite |
||
k |
number | Pente de la droite |
||
nom |
string |
<optional> |
''
|
Nom affichée de la droite |
color |
string |
<optional> |
'black'
|
Couleur de la droite : du type 'blue' ou du type '#f15929' |
Returns:
- Type
- Droite
droiteParPointEtPerpendiculaire(A, d, nomopt, coloropt) → {droiteParPointEtVecteur}
Trace la droite perpendiculaire à d passant par le point A
Examples
droiteParPointEtPerpendiculaire(M, d2) // Trace la droite perpendiculaire à d2 passant par le point M
droiteParPointEtPerpendiculaire(M, d2, 'd1', 'red') // Trace, en rouge, la droite d1 perpendiculaire à d2 passant par le point M
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point de la droite |
||
d |
Droite | Droite |
||
nom |
string |
<optional> |
''
|
Nom affichée de la droite |
color |
string |
<optional> |
'black'
|
Couleur de la droite : du type 'blue' ou du type '#f15929' |
Returns:
droiteParPointEtVecteur(A, v, nomopt, coloropt) → {Droite}
Trace la droite passant par le point A et de vecteur directeur v
Examples
droiteParPointEtVecteur(M, v1) // Trace la droite passant par le point M et de vecteur directeur v1
droiteParPointEtVecteur(M, v1, 'd1', 'red') // Trace, en rouge, la droite d1 passant par le point M et de vecteur directeur v1
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point de la droite |
||
v |
Vecteur | Vecteur directeur de la droite |
||
nom |
string |
<optional> |
''
|
Nom affichée de la droite |
color |
string |
<optional> |
'black'
|
Couleur de la droite : du type 'blue' ou du type '#f15929' |
Returns:
- Type
- Droite
droiteVerticaleParPoint(A, nomopt, coloropt) → {droiteParPointEtVecteur}
Trace la droite verticale passant par le point A
Examples
droiteVerticaleParPoint(M) // Trace la droite verticale passant par le point M
droiteVerticaleParPoint(M, 'd1', 'red') // Trace, en rouge, la droite verticale d1 passant par le point M
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point de la droite |
||
nom |
string |
<optional> |
''
|
Nom affichée de la droite |
color |
string |
<optional> |
'black'
|
Couleur de la droite : du type 'blue' ou du type '#f15929' |
Returns:
ellipse(O, rx, ry, coloropt) → {Ellipse}
Trace l'ellipse de centre O et de rayon rx et ry (la construction, dite “par réduction d’ordonnée”, montre que l'ellipse est la transformée de Newton de 2 cercles concentriques)
Examples
ellipse(M, 1, 3) // Trace, en noir, l'ellipse de centre M et de rayons 1 et 3
ellipse(M, 1, 3, 'red') // Trace, en rouge, l'ellipse de centre M et de rayons 1 et 3
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
O |
Point | Centre de l'ellipse |
||
rx |
number | Premier rayon de l'ellipse |
||
ry |
number | Second rayon de l'ellipse |
||
color |
string |
<optional> |
'black'
|
Couleur de l'ellipse : du type 'blue' ou du type '#f15929' |
Returns:
- Type
- Ellipse
engrenage(parametres, marqueur) → {Engrenage}
Parameters:
Name | Type | Description | ||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
parametres |
object | paramètres de l'objet voir ci-dessous Properties
|
||||||||||||||||||||||||||||||||||||||||||||||||
marqueur |
number | null | position angulaire en degrés d'un marqueur si de type number |
Returns:
- Type
- Engrenage
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
flecheH(D, A, texte, h) → {array}
- Source:
fonction utilisée par la classe Tableau pour créer une flèche
Parameters:
Name | Type | Default | Description |
---|---|---|---|
D |
Point | ||
A |
Point | ||
texte |
string | ||
h |
number |
1
|
Returns:
(Polyline|Segment|TexteParPoint)[]
- Type
- array
flecheV(D, A, texte, h) → {array}
- Source:
fonction utilisée par la classe Tableau pour créer une flèche
Parameters:
Name | Type | Default | Description |
---|---|---|---|
D |
Point | ||
A |
Point | ||
texte |
string | ||
h |
number |
1
|
Returns:
(Polyline|Segment|TexteParPoint)[]
- Type
- array
graphiqueInterpole()
grille(xminopt, yminopt, xmaxopt, ymaxopt, coloropt, opaciteopt, stepopt, pointillesopt) → {Grille}
Trace une grille quadrillée dont le coin en bas à gauche est (xmin, ymin) et celui à droite est au maximum (xmax, ymax), de couleur et opacité choisie, avec un pas choisi et avec ou sans pointillés
Examples
grid = grille() // Trace une grille avec toutes les options par défaut
grid = grille(-3, -3, 27, 18, 'red', 0.2, 0.5, true) // Trace une grille avec toutes les options différentes de celles par défaut
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
xmin |
number |
<optional> |
-30
|
Abscisse du coin en bas à gauche de la grille |
ymin |
number |
<optional> |
-30
|
Ordonnée du coin en bas à gauche de la grille |
xmax |
number |
<optional> |
30
|
Abscisse du coin en haut à droite de la grille |
ymax |
number |
<optional> |
30
|
Ordonnée du coin en haut à droite de la grille |
color |
string |
<optional> |
'gray'
|
Couleur de la grille : du type 'blue' ou du type '#f15929' |
opacite |
number |
<optional> |
0.4
|
Opacité de la grille : entre 0 et 1 |
step |
number |
<optional> |
1
|
Pas de la grille |
pointilles |
number |
<optional> |
0
|
Style des pointillés de la grille (entier entre 1 et 5). Si autre chose, pas de pointillés. |
Returns:
- Type
- Grille
hauteurTriangle(A, B, C, coloropt) → {Droite}
Trace la hauteur issue de A relative à [BC]
Examples
hauteurTriangle (M, N, P) // Trace, en noir, la hauteur issue de M relative à [NP]
hauteurTriangle (M, N, P, 'red') // Trace, en rouge, la hauteur issue de M relative à [NP]
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Point dont est issue la hauteur |
||
B |
Point | Première extrémité du segment dont est relative la hauteur |
||
C |
Point | Seconde extrémité du segment dont est relative la hauteur |
||
color |
string |
<optional> |
'black'
|
Couleur de cette hauteur : du type 'blue' ou du type '#f15929' |
Returns:
- Type
- Droite
homothetie(Objet, O, k, nomopt, positionLabelopt, coloropt) → {Point|Segment|Droite|Polygone|Vecteur}
Construit l'image d'un objet par homothétie
Examples
p2 = homothetie(p1 ,I ,2)
// p2 est l'image de p1 par une homothétie de centre I et de rapport 2
N = homothetie(M, I, 0.5, 'point N', 'right')
// N est l'image de M par une homothétie de centre I et de rapport 0.5. Le point sera affiché comme "point N" et ce nom sera écrit à droite de sa position.
s = homothetie(segment(A, B), I, -0.5, '', '','blue')
// s est l'image du segment [AB] par une homothétie de centre I et de rapport -0.5. s sera en bleu.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
Objet |
Point | Segment | Droite | Polygone | Vecteur | Objet MathAlea2d choisi parmi un point, un segment, une droite, un polygone ou un vecteur |
||
O |
Point | Centre de l'homothétie |
||
k |
number | Rapport de l'homothétie |
||
nom |
string |
<optional> |
''
|
Nom du point-image |
positionLabel |
string |
<optional> |
'above'
|
Position du point-image. 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'. |
color |
string |
<optional> |
'black'
|
Couleur de l'image : du type 'blue' ou du type '#f15929' (non valable pour un point et pour un vecteur) |
Returns:
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
integrale(f, parametres) → {Integrale}
Trace l'aire entre la courbe d'une fonction et l'axe des abscisses
Examples
integrale(g, {repere: r})
// Trace avec une épaisseur de 2, l'aire entre la courbe de la fonction g et l'axe des abscisses dans le repère r, tous deux précédemment définis.
integrale(g, {repere: r, epaisseur: 5, color: 'blue', couleurDeRemplissage: 'red'})
// Trace avec une épaisseur de 5, l'aire entre la courbe de la fonction g et l'axe des abscisses dans le repère r, tous deux précédemment définis. L'aire est entourée de bleu et remplie de rouge.
Parameters:
Name | Type | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f |
function | fonction dont on veut tracer l'aire entre sa courbe et l'axe des abscisses comme par exemple : const f = x => a * x ** 2 + b * x + c |
||||||||||||||||||||||||||||||||||||||||||||||||||
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- Integrale
labelLatexPoint(distanceopt, labelopt, parametres) → {LabelLatexPoint}
Associe à tous les points passés en paramètre, son label, défini préalablement en Latex. Par exemple, si besoin de nommer le point A_1.
Parameters:
Name | Type | Attributes | Default | Description | |||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
distance |
number |
<optional> |
1.5
|
Taille de l'angle |
|||||||||||||||||||||||||||||||||||
label |
string |
<optional> |
''
|
Si vide, alors affiche la mesure de l'angle sinon affiche ce label. |
|||||||||||||||||||||||||||||||||||
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- LabelLatexPoint
labelPoint(…args, coloropt) → {LabelPoint}
Nomme les points passés en argument, le nombre d'arguments n'est pas limité.
Examples
labelPoint(A,B,C) // Retourne le nom des points A, B et C en noir
labelPoint(A,B,C,'red') // Retourne le nom des points A, B et C en rouge
labelPoint(A,B,C,'#f15929') // Retourne le nom des points A, B et C en orange (code couleur HTML : #f15929)
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
args |
any |
<repeatable> |
Points mis à la suite |
|
color |
string |
<optional> |
'black'
|
Couleur des points : du type 'blue' ou du type '#f15929' |
Returns:
- Type
- LabelPoint
labelY(yminopt, ymaxopt, stepopt, coloropt, posopt, coeffopt) → {LabelY}
Place des labels sur un axe vertical précédemment
Examples
labelY()
// Note, sur un axe (prédéfini de 1 en 1), des labels noirs, de 0 à 20, de 2 en 2, avec un décalage de -0,6 par rapport à l'axe
labelY(0, 160, 2, 'red', -2, 20)
// Note, sur un axe (prédéfini de 1 en 1), des labels rouges, de 0 à 160, de 40 (2*20) en 40, avec un décalage de -2 par rapport à l'axe.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
ymin |
number |
<optional> |
1
|
Ordonnée minimale sur l'axe |
ymax |
number |
<optional> |
20
|
Ordonnée maximale sur l'axe |
step |
number |
<optional> |
1
|
Pas entre chaque label |
color |
string |
<optional> |
'black'
|
Couleur des labels : du type 'blue' ou du type '#f15929' |
pos |
number |
<optional> |
-0.6
|
Décalage entre les labels et l'axe vertical |
coeff |
number |
<optional> |
1
|
Coefficient multiplicatif sur chaque label |
Returns:
- Type
- LabelY
labyrinthe(parametres) → {Labyrinthe}
- Source:
Crée un ensemble de chemins possibles dans un labyrinthe. Cette fonction est à associer aux méthodes conçues pour.
Example
laby = labyrinthe ({ nbLignes: 4, nbColonnes: 5 })
// Crée l'ensemble de chemins possibles dans un labyrinthe à 4 lignes et 5 colonnes
Parameters:
Name | Type | Description | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
parametres |
Object | À saisir entre accolades Properties
|
Returns:
- Type
- Labyrinthe
LatexParCoordonnees(texte, x, y, coloropt, largeuropt, hauteuropt, colorBackgroundopt, tailleCaracteresopt)
Parameters:
Name | Type | Attributes | 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 |
<optional> |
couleur |
largeur |
Number |
<optional> |
Dimensions de la 'box' rectangulaire conteneur de la formule en pixels en considérant la taille de caractère 8='\footnotesize' |
hauteur |
Number |
<optional> |
Idem pour la hauteur de la box. Prévoir 20 par exemple pour une fraction. Permet le centrage correct. |
colorBackground |
String |
<optional> |
Couleur du fond de la box. Chaine vide pour un fond transparent. |
tailleCaracteres |
Number |
<optional> |
Taille de la police utilisée de 5 = \small à 20=\huge... agit sur la box en en modifiant les paramètres hauteur et largeur |
LatexParCoordonneesBox(texte, x, y, coloropt, largeuropt, hauteuropt, colorBackgroundopt, tailleCaracteresopt, {options})
Parameters:
Name | Type | Attributes | 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 |
<optional> |
couleur |
largeur |
Number |
<optional> |
Dimensions de la 'box' rectangulaire conteneur de la formule en pixels en considérant la taille de caractère 8='\footnotesize' |
hauteur |
Number |
<optional> |
Idem pour la hauteur de la box. Prévoir 20 par exemple pour une fraction. Permet le centrage correct. |
colorBackground |
String |
<optional> |
Couleur du fond de la box. Chaine vide pour un fond transparent. |
tailleCaracteres |
Number |
<optional> |
Taille de la police utilisée de 5 = \small à 20=\huge... agit sur la box en en modifiant les paramètres hauteur et largeur |
{options} |
Struct | options.anchor pour forcer la boite |
latexParPoint()
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"
Example
leveCrayon(lutin) // Sort lutin du mode "trace"
Parameters:
Name | Type | Description |
---|---|---|
lutin |
ObjetLutin |
lignesHorizontales(xminopt, yminopt, xmaxopt, ymaxopt, coloropt, opaciteopt, stepopt, pointillesopt) → {LignesHorizontales}
Trace des parallèles à l'axe des abscisses
Examples
grid = lignesHorizontales() // Trace des parallèles à l'axe des abscisses avec toutes les options par défaut
grid = lignesHorizontales(-3, -3, 27, 18, 'red', 0.2, 0.5, true) // Trace des parallèles à l'axe des abscisses avec toutes les options différentes de celles par défaut
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
xmin |
number |
<optional> |
-30
|
Abscisse du coin en bas à gauche de ces parallèles |
ymin |
number |
<optional> |
-30
|
Ordonnée du coin en bas à gauche de ces parallèles |
xmax |
number |
<optional> |
30
|
Abscisse du coin en haut à droite de ces parallèles |
ymax |
number |
<optional> |
30
|
Ordonnée du coin en haut à droite de ces parallèles |
color |
string |
<optional> |
'gray'
|
Couleur de ces parallèles : du type 'blue' ou du type '#f15929' |
opacite |
number |
<optional> |
0.4
|
Opacité de ces parallèles : entre 0 et 1 |
step |
number |
<optional> |
1
|
Pas de ces parallèles |
pointilles |
number |
<optional> |
0
|
Style des pointillés de ces parallèles (entier entre 1 et 5). Si autre chose, pas de pointillés. |
Returns:
- Type
- LignesHorizontales
lignesVerticales(xminopt, yminopt, xmaxopt, ymaxopt, coloropt, opaciteopt, stepopt, pointillesopt) → {LignesVerticales}
Trace des parallèles à l'axe des ordonnées
Examples
grid = lignesHorizontales() // Trace des parallèles à l'axe des ordonnées avec toutes les options par défaut
grid = lignesHorizontales(-3, -3, 27, 18, 'red', 0.2, 0.5, true) // Trace des parallèles à l'axe des ordonnées avec toutes les options différentes de celles par défaut
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
xmin |
number |
<optional> |
-30
|
Abscisse du coin en bas à gauche de ces parallèles |
ymin |
number |
<optional> |
-30
|
Ordonnée du coin en bas à gauche de ces parallèles |
xmax |
number |
<optional> |
30
|
Abscisse du coin en haut à droite de ces parallèles |
ymax |
number |
<optional> |
30
|
Ordonnée du coin en haut à droite de ces parallèles |
color |
string |
<optional> |
'gray'
|
Couleur de ces parallèles : du type 'blue' ou du type '#f15929' |
opacite |
number |
<optional> |
0.4
|
Opacité de ces parallèles : entre 0 et 1 |
step |
number |
<optional> |
1
|
Pas de ces parallèles |
pointilles |
number |
<optional> |
0
|
Style des pointillés de ces parallèles (entier entre 1 et 5). Si autre chose, pas de pointillés. |
Returns:
- Type
- LignesVerticales
longueur(A, B, arrondiopt)
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. |
mathalea2d()
- Source:
mathalea2d(xmin,xmax,ymin,ymax,objets)
medianeTriangle(A, B, C, color)
Médiane issue de A relative à [BC]
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
C |
Point | |
color |
string |
mediatrice(A, B, nomopt, couleurMediatriceopt, coloropt, couleurConstructionopt, constructionopt, detailopt, markmilieuopt, markrayonsopt, epaisseurMediatriceopt, opaciteMediatriceopt, pointillesMediatriceopt) → {Mediatrice}
Trace la médiatrice d'un segment, en laissant éventuellement apparents les traits de construction au compas
Examples
mediatrice(M,N)
// Trace, en rouge, la médiatrice du segment[MN], d'épaisseur 1, avec une opacité de 100 % sans autre option
mediatrice(M,N,'d','blue')
// Trace, en bleu, la médiatrice du segment[MN], d'épaisseur 1, avec une opacité de 100 % et qui s'appelle 'd'
mediatrice(M,N,'','blue','red','green',true,true,'OO','XX',2,0.5,3)
// Trace, en bleu, la médiatrice du segment[MN], d'épaisseur 2, avec une opacité de 50 % sans nom
// Les traits de construction sont dessinés en vert avec la marque 'OO' pour le segment initial et la marque 'XX' pour les rayons, toutes ces marques étant rouge.
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | Première extrémité du segment |
||
B |
Point | Seconde extrémité du segment |
||
nom |
string |
<optional> |
''
|
Nom affichée de la droite |
couleurMediatrice |
string |
<optional> |
'red'
|
Couleur de la médiatrice : du type 'blue' ou du type '#f15929' |
color |
string |
<optional> |
'blue'
|
Couleur du codage : du type 'blue' ou du type '#f15929'. |
couleurConstruction |
string |
<optional> |
'black'
|
Couleur des traits de construction : du type 'blue' ou du type '#f15929'. |
construction |
boolean |
<optional> |
false
|
Si construction est true, alors on affiche le codage et aussi les coups de compas utiles à la construction. |
detail |
boolean |
<optional> |
false
|
Si detail est true, alors on affiche aussi en pointillés les rayons utiles à la construction. |
markmilieu |
string |
<optional> |
'x'
|
Symbole posé sur les deux parties du segment |
markrayons |
string |
<optional> |
'||'
|
Symbole posé sur les quatre rayons (si détail est true) |
epaisseurMediatrice |
number |
<optional> |
1
|
Epaisseur de la médiatrice |
opaciteMediatrice |
number |
<optional> |
1
|
Taux d'opacité de la médiatrice |
pointillesMediatrice |
number |
<optional> |
0
|
Si cette valeur est entre 1 et 5, la médiatrice est en pointillés |
Returns:
- Type
- Mediatrice
mettrexA(x, lutin)
- Source:
Change en x à l'abscisse du lutin
Example
mettrexA(10,lutin) // L'abscisse de lutin devient 10.
Parameters:
Name | Type | Description |
---|---|---|
x |
number | Nouvelle abscisse |
lutin |
ObjetLutin | Lutin |
mettreyA(y, lutin)
- Source:
change en y l'ordonnée du lutin
Example
mettreyA(10,lutin) // L'ordonnée de lutin devient 10.
Parameters:
Name | Type | Description |
---|---|---|
y |
number | Nouvelle ordonnée |
lutin |
ObjetLutin | Lutin |
milieu()
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
motifs(index)
- Source:
Parameters:
Name | Type | Description |
---|---|---|
index |
number | Choix du motif le nom du motif sert dans la fonction pattern |
NommePolygone()
Si les noms peuvent avoir plusieurs caractères, il faudra ajouter des virgules entre chaque nom dans le string passé en argument.
Examples
nommePolygone (p, "A',B',C',D',E'", 0.5, 'red')
nommePolygone (p,'ABCDE',0.5,'red') nomme les sommets du polygone A, B, C, D et E. Les labels sont placés à une distance de 0,5 cm des sommets
NomVecteurParPosition()
norme()
norme(V) renvoie la norme du vecteur
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 |
ObjetLutin |
orthoCentre(A, B, C, nom)
Orthocentre du triangle ABC
Parameters:
Name | Type | Description |
---|---|---|
A |
Point | |
B |
Point | |
C |
Point | |
nom |
string |
parallelogramme2points1hauteur(NOM, A, B, h) → {polygoneAvecNom}
parallelogramme2points1hauteur(A,B,5) renvoie un parallélogramme ABCD de base [AB] et de hauteur h parallelogramme2points1hauteur(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
parallelogramme3points(NOM, A, B, C) → {polygoneAvecNom}
fonction 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
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. |
Pave(Longueur, largeur, profondeur)
Parameters:
Name | Type | Description |
---|---|---|
Longueur |
int | |
largeur |
int | |
profondeur |
int |
Plot(x, y, param2)
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(x, y, A, positionLabel) → {Point}
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 |
positionLabel |
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()
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 objets 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 |
pointDansRepere(x, y, repere)
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 |
pointIntersectionCC()
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(d, f, nom, positionLabelopt) → {Point}
Renvoie 'M' le point d'intersection des droites d1 et d2
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
d |
Droite | |||
f |
Droite | |||
nom |
string | le 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)
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. |
pointSurCercle(c, angle, nom, positionLabel)
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}
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()
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() → {Polygone}
Propriétés possibles : .color, .opacite, .epaisseur, .couleurDeRemplissage, .opaciteDeRemplissage, .hachures (true or false), .distanceDesHachures, .epaisseurDesHachures,.couleurDesHachures
Examples
polygone(A,B,C,D,E) //Trace ABCDE
polygone([A,B,C,D],"blue") // Trace ABCD en bleu
polygone([A,B,C,D],"#f15929") // Trace ABCD en orange (code couleur HTML : #f15929)
Returns:
objet Polygone
- Type
- Polygone
polygoneATrous(dataopt, holesopt, nomsopt, coloropt, couleurDeRemplissageopt, couleurDeFondopt) → {PolygoneaTrou}
Cet objet permet de créer un polygone avec une surface contenant des 'trous' eux-mêmes polygonaux cerise sur le gâteau, la propriété this.triangulation fournit une liste de triangles pavant le polygone
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
data |
Array.<number> |
<optional> |
[]
|
contient la liste des coordonnées des sommets (contour puis trous) 2 coordonnées par point dans l'ordre abscisse, ordonnée |
holes |
Array.<number> |
<optional> |
[]
|
tableau à une seule dimension contenant les indices des points qui démarrent un 'trou' dans le tableau data (exemple : holes = [4, 8] indique que les points 4 à 7 définissent un trou ainsi que 8 et suivants, donc les coordonnées 8 à 15 et 16 à ...(ne pas oublier que 1 point = 2 coordonnées)) |
noms |
string |
<optional> |
''
|
contient les noms des sommets |
color |
string |
<optional> |
'black'
|
est la couleur des bords |
couleurDeRemplissage |
string |
<optional> |
'blue'
|
est la couleur de la surface |
couleurDeFond |
string |
<optional> |
'white'
|
est la couleur de remplissage des trous |
Returns:
un polygone à trous (ou pas : il peut ne pas y avoir de trou !)
- Type
- PolygoneaTrou
polygoneAvecNom(…args) → {array}
Crée un groupe d'objets contenant le polygone et ses sommets
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
args |
any |
<repeatable> |
Returns:
[polygone,sommets] Si le dernier argument est un nombre, celui-ci sera utilisé pour fixer la distance entre le sommet et le label (par défaut 0.5)
- Type
- array
polygoneRegulier(A, B, n, coloropt)
Trace le polygone régulier direct à n côtés qui a pour côté [AB] Pour tracer le polygone régulier indirect de côté [AB], on iversera A et B
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
A |
Point | |||
B |
Point | |||
n |
integer | Nombre de côtés |
||
color |
string |
<optional> |
'black'
|
Couleur de l'arc ou 'none' : du type 'blue' ou du type '#f15929' |
polygoneRegulierParCentreEtRayon()
polygoneRegulierParCentreEtRayon(O,r,n) //Trace le polygone régulier à n côtés et de rayon r
polygoneToFlatArray(P) → {Array.<number>}
Parameters:
Name | Type | Description |
---|---|---|
P |
Polygone |
Returns:
retourne la liste des coordonnées des sommets de P dans un seul tableau.
- Type
- Array.<number>
Polyline()
polyline(A,B,C,D,E) //Trace la ligne brisée ABCDE
polyline()
Trace une ligne brisée
Examples
polyline(A,B,C,D,E) // Trace la ligne brisée ABCDE en noir
polyline([A,B,C,D,E],'blue') // Trace la ligne brisée ABCDE en bleu
polyline([A,B,C,D,E],'#f15929') // Trace la ligne brisée ABCDE en orange (code couleur HTML : #f15929)
positionLabelDroite(d, param1) → {Point}
Parameters:
Name | Type | Description |
---|---|---|
d |
droite | |
param1 |
number | les bordures de la fenêtre |
Returns:
le point qui servira à placer le label.
- Type
- Point
projectionOrtho()
N = projectionOrtho(M,d,'N','below left')
rapporteur(semi, avecNombre, precisionAuDegre, stepGraduation, rayonsVisibles, param0) → {Rapporteur}
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
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 |
renommePolygone()
en une fois tous les sommets d'un polygone avec le tableau de string fourni attention si on passe un string comme 'ABCD' ça fonctionne aussi... Si on veut des noms de points à plus de 1 caractère, il faut soit les passer en tableau soit les séparer par des virgules au sein du string
Example
renommePolygone(p, "A',B',C',D'") ou renommePolygone(p, ["A'","B'","C'","D'"])
Repere()
repere({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})
repere() trace un repère classique. De nombreux paramètres permettent d'en modifier l'aspect
repere(params) → {object}
Parameters:
Name | Type | Description |
---|---|---|
params |
object |
Returns:
- Type
- object
roseDesVents() → {RoseDesVents}
- Source:
Crée une instance de RoseDesVents (une boussole Scratch) Il n'y a pas d'arguments, c'est un objet statique qui a sa méthode svg() et sa méthode tikz() Il est difficile de modifier la taille de l'objet à cause du texte des blocks
Returns:
- Type
- RoseDesVents
rotation(A, O, angle, nomopt, positionLabelopt, coloropt)
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 |
positionLabel |
string |
<optional> |
'above'
|
|
color |
string |
<optional> |
'black'
|
Code couleur HTML acceptée |
Returns:
L'image de A par la rotation de centre O et d'angle angle
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
segment(…args)
Examples
segment(A,B,'blue') // Segment [AB] de couleur bleu
segment(x1,y1,x2,y2,'#f15929') // Segment dont les extrémités sont respectivement (x1,y1) et (x2,y2), de couleur orange (#f15929)
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
args |
args |
<repeatable> |
Points ou coordonnées + couleur facultative en dernier |
segmentAvecExtremites(…args, color)
Examples
segmentAvecExtremites(A,B,'blue')
segmentAvecExtremites(x1,y1,x2,y2,'#f15929')
Parameters:
Name | Type | Attributes | Description |
---|---|---|---|
args |
args |
<repeatable> |
Points ou coordonnées |
color |
string | Facultatif |
SemiEllipse(centre, Rx, Ry, hemisphere, pointilles, rayon, color, couleurDeRemplissage, opaciteDeRemplissage) → {SemiEllipse}
Parameters:
Name | Type | Description |
---|---|---|
centre |
Point | centre de l'ellipse |
Rx |
number | rayon en X |
Ry |
number | rayon en Y |
hemisphere |
string | 'nord' pour tracer au dessus du centre, 'sud' pour tracer en dessous |
pointilles |
boolean | number | Si false, l'ar est en trait plein, sinon en pointillés |
rayon |
boolean | Si true, alors l'arc est fermé par un segment. |
color |
string | Facultatif, 'black' par défaut |
couleurDeRemplissage |
string | si 'none' alors pas de remplissage. |
opaciteDeRemplissage |
number | Transparence de remplissage de 0 à 1. Facultatif, 0.2 par défaut |
Returns:
Objet SemiEllipse
- Type
- SemiEllipse
semiEllipse(centre, Rx, Ry, hemisphere, pointilles, rayon, color, couleurDeRemplissage, opaciteDeRemplissage) → {SemiEllipse}
Parameters:
Name | Type | Description |
---|---|---|
centre |
Point | centre de l'ellipse |
Rx |
number | rayon en X |
Ry |
number | rayon en Y |
hemisphere |
string | 'nord' pour tracer au dessus du centre, 'sud' pour tracer en dessous |
pointilles |
boolean | number | Si false, l'ar est en trait plein, sinon en pointillés |
rayon |
boolean | Si true, alors l'arc est fermé par un segment. |
color |
string | Facultatif, 'black' par défaut |
couleurDeRemplissage |
string | si 'none' alors pas de remplissage. |
opaciteDeRemplissage |
number | Transparence de remplissage de 0 à 1. Facultatif, 0.2 par défaut |
Returns:
Objet SemiEllipse
- Type
- SemiEllipse
SensDeRotation()
seyes(xmin, ymin, xmax, ymax)
Fais un quadrillage avec des grands carreaux.
Pour une sortie LaTeX, il faut penser à ajouter scale = .8
Parameters:
Name | Type | Description |
---|---|---|
xmin |
number | |
ymin |
number | |
xmax |
number | |
ymax |
number |
similitude(A, O, a, k, nom, positionLabel)
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 |
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, coloropt) → {Point}
Renvoie le point M symétrique du point A par la droite d.
Parameters:
Name | Type | Attributes | Default | 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. |
||
color |
string |
<optional> |
'black'
|
Code couleur HTML acceptée |
Returns:
M image de A par la symétrie axiale d'axe d.
- Type
- Point
Tableau()
- Source:
Réalise un tableau typique des exercices de proportionnalité avec d'éventuelles flèches
TexteParPoint()
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 finit par des $ la chaine est traitée par latexParPoint
texteParPosition(texte, x, y, orientation, coloropt, scaleopt, ancrageDeRotationopt, mathOnopt)
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. |
TexteSurArc()
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, horizontalopt) → {object}
Écrit un texte au "milieu" de l'arc AB au dessus si A est le point le plus à gauche sinon en 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'
|
Code couleur HTML accepté |
d |
number |
<optional> |
0.5
|
Distance à la droite. |
horizontal |
boolean |
<optional> |
false
|
Décide si le texte est horizontal ou pas, quelle que soit la valeur de angle. |
Returns:
LatexParCoordonnees si le premier caractère est '$', TexteParPoint sinon
- Type
- object
TexteSurSegment()
texteSurSegment('mon texte',A,B) // Écrit un texte au milieu de [AB] au dessus si A est le point le plus à gauche sinon en dessous, ou alors horizontalement
texteSurSegment(texte, A, B, coloropt, dopt, horizontalopt) → {object}
Écrit un texte au milieu de [AB] au dessus si A est le point le plus à gauche sinon au dessous ou bien horizontal
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
texte |
string | |||
A |
Point | |||
B |
Point | |||
color |
string |
<optional> |
'black'
|
Code couleur HTML accepté |
d |
number |
<optional> |
0.5
|
Distance à la droite. |
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
tournerD(a, lutin)
- Source:
Fait tourner de a degrés le lutin dans le sens indirect
Parameters:
Name | Type | Description |
---|---|---|
a |
number | |
lutin |
ObjetLutin |
tournerG(a, lutin)
- Source:
Fait tourner de a degrés le lutin dans le sens direct
Parameters:
Name | Type | Description |
---|---|---|
a |
number | |
lutin |
ObjetLutin |
TraceBarre(x, hauteur, legende, epaisseur, couleur, opaciteDeRemplissage, angle)
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)
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()
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)
Trace un graphique cartésien dans un repère
Parameters:
Name | Type | Description |
---|---|---|
data |
array | |
repere |
object |
TracePoint()
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 Après coup, on peut notamment changer l'épaissseur, le style et l'opacité du point par : pt = tracePoint(A) pt.epaisseur = 5 (par défaut : 1) pt.opacite = 0.2 (par défaut : 0.8 = 80%) pt.style = '#' (choix parmi 'x','o','#','|','+','.' et par défaut : 'x')
tracePoint(args) → {TracePoint}
Examples
tracePoint(A,B,C,'red) // Trace les points A,B,C précédemment créés en rouge
tracePoint(A).style = '|' // Le style du point A sera '|' et non 'x' par défaut.
tracePoint(A).epaisseur = 5 // L'épaisseur du style du point sera 5 et non 1 par défaut.
tracePoint(A).opacite = 0.4 // L'opacité du style du point sera 40% et non 80%(0.8) par défaut.
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()
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
translation(O, v, nom, positionLabel, coloropt)
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 | Attributes | Default | 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 |
||
color |
string |
<optional> |
'black'
|
Code couleur HTML acceptée |
translation2Points()
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
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
triangle2points1angle1longueur(A, B, a, l, n)
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)
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}
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()
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}
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
Vecteur()
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. v.representant(E,'blue') // Dessine le vecteur v issu de E, en bleu. Commenter toutes les méthodes possibles
vecteur()
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.