sarmateGraph v1.0

Liste des fonctions

arcCercle
arcCercle([point],[rayon],[angle1],[angle2],[pointillés]) trace l'arc de cercle de centre [point] de rayon [rayon] entre les angles [angle1] et [angle2]. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

arcCercle([0,0],2,0,%PI/4)
Trace l'arc de cercle de centre [0,0], de rayon 2 entre les angles 0 et π/4 (en radians).

transparence = 1 trait = 5 couleur = noir cercle([0,0],5) peinture = bleu arcCercle([0,0],5,0,%PI/3) peinture = rose arcCercle([0,0],5,%PI/3,2*%PI/3) peinture = vert arcCercle([0,0],5,2*%PI/3,3*%PI/3) peinture = orange arcCercle([0,0],5,3*%PI/3,4*%PI/3) peinture = marron arcCercle([0,0],5,4*%PI/3,5*%PI/3) peinture = jaune arcCercle([0,0],5,5*%PI/3,6*%PI/3)
Les camemberts d'un célèbre jeu en jouant sur les couleurs de contours, de remplissage et sur les angles.
AxeX
AxeX = true l'axe des abscisses est affiché.
AxeX = false l'axe des abscisses n'est pas affiché.
AxeY
AxeY = true l'axe des ordonnées est affiché.
AxeY = false l'axe des ordonnées n'est pas affiché.
cercle
cercle([point],[rayon],[pointillés]) trace le cercle de centre [point] et de rayon [rayon]. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

cercle([0,0],2)
Trace le cercle de centre [0,0] et de rayon 2.

B = [-2,1] r = 3 cercle(B,r)
On définit tout d'abord le point B et le nombre r, puis on trace le cercle de centre B et de rayon r.

Xmin = 0 Xmax = 1 Ymin = 0 Ymax =1 couleur = noir peinture = bleu transparence = 0.1 for(i=0;i<10;i++){ B = [rand(),rand()] r = rand()/2 cercle(B,r) }
Le repère est définit à [0;1] en abscisse et à [0;1] en ordonnée.
La couleur des traits de construction sera le noir et celle de remplissage le bleu. Le remplissage sera transparent avec une opacité de 10%.
On exécute une boucle Pour 10 fois, on à chaque itération on construit un cercle dont le centre aura des coordonnées aléatoires ainsi qu'un rayon aléatoire.
chaine
chaine([liste],[pointillés]) construit un ligne brisé dont les sommets sont donnés dans [liste]. Chaque élément de [liste] est donc un point. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

chaine([[1,0],[6,0],[6,4],[3,5],[3,8],[-6,2]])
couleur
couleur = [couleur]
Modifie la couleur du tracé des objets à partir de l'instruction.
trait = 3 couleur = bleu segment([0,0],[3,3]) couleur = rouge segment([0,0],[0,5]) couleur = vert segment([0,0],[-3,3])
distance
distance([point1],[point2])
Retourne la distance entre les points [point1] et [point2].

distance([0,0],[1,1]) texte(d,[-2,0])
droite
droite([point1],[point2],[pointillés]) trace une droite passant par les deux points [point1] et [point1]. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

droite([0,0],[1,0])
Trace une droite passant par les points [0,0] et [1,0].

A = [-1,1] B = [3,-1] droite(A,B)
On définit tout d'abord les points A et B, puis on trace la droite passant par A et B.
droiteParam
droite([point],[vecteur],[pointillés]) trace une droite passant par le point [point] et dirigée par le vecteur [vecteur]. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

droiteParam([0,0,0],[1,1,1]) Trace une droite passant par les points [0,0,0] et dirigée par le vecteur [1,1,1].

A = [-1,1] U = [3,-1] droiteParam(A,U)
On définit tout d'abord les points A et le vecteur U, puis on trace la droite passant par A et dirigée par U.
GradX
GradX = [val]
La graduation de la grille en abscisse se fait toute les [val] unités.
GradY
GradY = [val]
La graduation de la grille en ordonnée se fait toute les [val] unités.
graphe
graphe([fonction],[Xstart],[Xend])
Construit le graphique de [fonction] entre [Xstart] et [Xend].

Xmin = -4*%PI Xmax = 4*%PI Ymin = -10 Ymax = 10 GradX = %PI/2 GradY = 1 AxeX = true AxeY = true Grille = true function f(x){ return x*cos(x) } couleur = bleu trait = 2 graphe(f,-4*%PI,4*%PI)
Grille
Grille = true le quadrillage basé sur GradX et GradY est affiché.
Grille = false le quadrillage basé sur GradX et GradY n'est pas affiché.
ht
ht([point1],[nombre],[point2])
Retourne le point image de [point2] dans l'homothétie de centre [point1] et de rapport [nombre].

AxeX = true AxeY = true Grille = true A = [-3,2] B = [1,0] point(A) point(B) C = ht(A,2,B) point(C)
peinture
peinture = [couleur]
Modifie la couleur de remplissage des objets à partir de l'instruction. Attention par défaut l'opacité pour la couleur de remplissage est à 0, il faudra pour cela modifier la valeur de "transparence" auparavant.
trait = 3 couleur = bleu peinture = rouge transparence = 0.1 cercle([0,0],3)
peintureCourbe
peintureCourbe([fonction],[Xstart],[Xend])
Colorie la surface comprise entre l'axe des abscisses, le graphique de [fonction] et les droites verticales d'équation x=[Xstart] et x=[Xend].

Xmin = -4*%PI Xmax = 4*%PI Ymin = -10 Ymax = 10 GradX = %PI/2 GradY = 1 AxeX = true AxeY = true Grille = true function f(x){ return x*cos(x) } couleur = bleu trait = 2 transparence = 0.1 peinture = vert peintureCourbe(f,-4*%PI,4*%PI) graphe(f,-4*%PI,4*%PI)
point
point([point])
Construit un point au point [point].

point([2,3]) construit le point de coordonnées [2,3].

A = [-1,2] point(A)On définit d'abord le point A et ensuite on le dessine.
poly
poly([liste],[pointillés]) construit un polygone dont les sommets sont donnés dans [liste]. Chaque élément de [liste] est donc un point. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

poly([[0,0],[6,0],[6,4],[3,5],[0,4]])
proj
proj([vecteur],[point1],[point2]) retourne le projeté du point [point2] sur la droite dirigée par [vecteur] et passant par [point1].

U = [1,1] C = [-3,-2] droiteParam(C,U) A = [5,-3] point(A) B = proj(U,C,A) point(B)
A = [5,0,-1] point(A) traceAxes3d() U = [0,1,1] C = [0,5,0] droiteParam(C,U) B = proj3d(U,C,A) point(B)
quadri
quadri([point1],[point2],[point3],[point4],[pointillés]).
Trace un quadrilatère de sommets [point1], [point2], [point3] et [point4]. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

A = [-1,-3] B = [3,-6] C = [5,6] D = [0,8] quadri(A,B,C,D)
rectangle
rectangle([point],[distanceX],[distanceY],[pointillés])
Trace un rectangle à partir du point [point] en se déplaçant vers la droite de [distanceX] et vers le bas de [distanceY]. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

Grille = true AxeX = true AxeY = true rectangle([1,3],3,2)
On affiche la grille, les axes puis on trace le rectangle à partir du point [1,3], on se déplace de 3 en abscisse puis de 2 en ordonnée pour obtenir les quatre sommets.

Xmin = 0 Xmax = 1 Ymin = 0 Ymax = 1 trait = 2 couleur = noir transparence = 0.15 for(i=0;i<15;i++){ A = [rand(),rand()] L = rand()/2+0.2 l = rand()/2+0.2 n = entAlea(0,3) if (n==0){peinture = bleu} if (n==1){peinture = rouge} if (n==2){peinture = rose} if (n==3){peinture = vert} rectangle(A,L,l) }
On construit ici aléatoirement des rectangles avec également des couleurs de remplissage aléatoires.
rotation2d
rotation3d([point1],[angle],[point2]) retourne l'image de [point2] dans la rotation de centre [point1] et d'angle [angle].

C = [-5,0] A = [5,0] angle = %PI/6 point(C) point(A) B = rotation2d(C,angle,A) point(B) segment(C,A) segment(C,B)
rotation3d
rotation3d([vecteur],[angle],[point1],[point2]) retourne l'image de [point2] dans la rotation d'axe dirigé par [vecteur] passant par [point1] et d'angle [angle].

A = [5,0,0] point(A) U = [0,1,1] angle = 0.05 C = [0,5,0] setInterval(function(){trace()},50) function trace(){ traceAxes3d() droiteParam(C,U) A = rotation3d(U,angle,C,A) point(A) point(C) }
segment
segment([point1],[point2],[pointillés]) trace le segment d'extrémités [point1] et [point1]. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

segment([0,0],[1,0]) Trace le segment d'extrémités les points [0,0] et [1,0].

A = [-1,1] B = [3,-1] segment(A,B) On définit tout d'abord les points A et B, puis on trace le segment [AB].
symA
symA([vecteur],[point1],[point2])
Retourne le point image de [point2] dans la symétrie d'axe la droite passant par [point1] et dirigée par le vecteur [vecteur].

AxeX = true AxeY = true Grille = true A = [-3,2] B = [-1,-3] U = [2,1] point(A) droiteParam(B,U) C = symA(U,B,A) point(C) segment(A,C,[3,3])
symC
symC([point1],[point2])
Retourne le point image de [point2] dans la symétrie de centre [point1].

AxeX = true AxeY = true Grille = true A = [-5,2] B = [-1,-3] point(A) point(B) C = symC(B,A) point(C)
texte
texte([var],[point])
La variable [var] est affichée au point [point].

texte("Cercle",[0,0]) affiche la chaîne de caractère "Cercle" au point de coordonnées [0,0].
traceAxes3d()
traceAxes3d()
Trace les axes d'un repère de l'espace.

traceAxes3d()
trait
trait =[val]
L'instruction permet de modifier l'épaisseur du tracé des objets.

Xmin = -1 Xmax = 10 Ymin = -10 Ymax = 10 for(i=0;i<10;i++){ trait = i segment([i,-10],[i,10]) }
translation
translation([vecteur],[point])
Retourne le point image de [point] dans la translation de vecteur [vecteur].

AxeX = true AxeY = true Grille = true A = [-5,2] U = [3,-3] point(A) B = translation(U,A) point(B)
transparence
transparence = [val]
[val] est un nombre entre 0 et 1. L'instruction permet de modifier l'opacité de la couleur de remplissage :
transparence = 0 &rar; la couleur de remplissage est transparente.
transparence = 1 &rar; la couleur de remplissage est complètement opaque.
Grille = true Xmin = -10 Xmax = 10 Ymin = -10 Ymax = 10 trait = 3 couleur = bleu peinture = rouge transparence = 0 cercle([-7,0],2) transparence = 0.1 cercle([-4,0],2) transparence = 0.5 cercle([-1,0],2) transparence = 1 cercle([2,0],2)
triangle
triangle([point1],[point2],[point3],[pointillés])
Construit un triangle entre les points [point1], [point2] et [point3]. Le paramètre [pointillés] est optionnel : il permet de tracer en pointillés la figure à l'aide de deux paramètre [nombre de pixels pleins, nombre de pixels vide].

triangle([0,0],[5,-1],[2,4]) Construit le triangle de sommet [0,0],[5,-1] et [2,4].

transparence = 0.2 peinture = vert triangle([0,0],[5,-1],[2,4])

Construit le triangle de sommet [0,0],[5,-1] et [2,4] en le remplissant de la couleur verte au seuil de transparence 0.2.

transparence = 0.2 peinture = vert trait = 2 // Taille du premier côté r = 10 // Facteur de réduction entre les triangles facteur = 1.1 // Nombre de triangles nb = 16 rectangle([-12,12],22,22) transparence = 0.5 couleur = blanc peinture = marron for(t=0;t<2*%PI;t=t+2*%PI/nb){ r = r/facteur triangle([0,0],[r*cos(t),r*sin(t)],[r*cos(t+2*%PI/nb)/facteur,r*sin(t+2*%PI/nb)/facteur]) }
Un escargot utilisant la trigonométrie.
vec
vec([point1],[point2])
Retourne le vecteur d'origine [point1] et d'extrémité [point2].
Xmin
Xmin = [val]
L'abscisse du point le plus à gauche du graphique est égale à [val]. Par défaut Xmin = -10.
Xmax
Xmax = [val]
L'abscisse du point le plus à droite du graphique est égale à [val]. Par défaut Xmax = 10.
Ymin
Ymin = [val]
L'ordonnée du point le plus bas du graphique est égale à [val]. Par défaut Ymin = -10.
Ymax
Ymax = [val]
L'ordonnée du point le plus haut du graphique est égale à [val]. Par défaut Ymax = 10.

Exemples

Un quadrillage à effet d'optique Xmin = -1 Xmax = 9.6 Ymin = -1 Ymax = 9.6 couleur = noir for(i=0;i<20;i++){ trait = i/1.2 couleur = noir segment([i/2,-10],[i/2,10]) segment([-10,i/2],[10,i/2]) }
Une spirale Xmin = -10 Xmax = 10 Ymin = -10 Ymax = 10 pas = 0.01 trait = 2 for(t=0;t<48*%PI;t=t+pas){ A = [0.1*t*cos(t),0.1*t*sin(t)] B = [0.1*(t+pas)*cos(t+pas),0.1*(t+pas)*sin(t+pas)] segment(A,B) }
Des segments aléatoires Xmin = 0 Xmax = 1 Ymin = 0 Ymax = 1 trait = 2 peinture = noir transparence = 1 rectangle([-1,2],5,5) couleur = blanc A = [rand(),rand()] point(A) for(t=0;t<25;t++){ n = entAlea(0,5) if (n==0){couleur = bleu} if (n==1){couleur = rouge} if (n==2){couleur = rose} if (n==3){couleur = vert} if (n==4){couleur = blanc} if (n==4){couleur = jaune} B = [rand(),rand()] segment(A,B) point(B) A = B }
Quelques cardioïdes Xmin = -3 Xmax = 20 Ymin = -20 Ymax = 20 for(a = 0.5;a<10;a=a*1.1){ pas = 0.1 for(t=0;t<2*%PI;t=t+pas){ A=[a*cos(t)*(1+cos(t)),a*sin(t)*(1+cos(t))] B=[a*cos(t+pas)*(1+cos(t+pas)),a*sin(t+pas)*(1+cos(t+pas))] segment(A,B) } }
Fractale de Mandelbrot Xmin = -1.5 Xmax = 0.5 Ymin = -1 Ymax = 1 trait = 0.3 couleur = noir itMax = 50 for(x=-2;x<=2;x=x+2/400){ for(y=-2;y<=2;y=y+1/200){ it = 0 tmp = 0 z_r = 0 z_i = 0 test = z_r*z_r+z_i*z_i while( test<4 && it<itMax ){ tmp = z_r z_r = z_r*z_r-z_i*z_i+x z_i = 2*z_i*tmp + y it++ test = z_r*z_r+z_i*z_i } if( it == itMax ){point([x,y])} } }
Fractale de Mandelbrot avec des couleurs Xmin = -2.1 Xmax = 0.5 Ymin = -1.3 Ymax = 1.3 trait = 0.3 couleur = noir itMax = 50 for(x=-2.1;x<=0.5;x=x+2.6/400){ for(y=-1.3;y<=1.3;y=y+2.6/400){ it = 0 tmp = 0 z_r = 0 z_i = 0 test = z_r*z_r+z_i*z_i while( test<4 && it<itMax ){ tmp = z_r z_r = z_r*z_r-z_i*z_i+x z_i = 2*z_i*tmp + y it++ test = z_r*z_r+z_i*z_i } if( it == itMax ){couleur = blanc} if( it < 45 ){couleur = "#38388c"} if( it < 40 ){couleur = "#0000ff"} if( it < 35 ){couleur = "#6969e4"} if( it < 30 ){couleur = "#7575ce"} if( it < 25 ){couleur = "#9797e4"} if( it < 22 ){couleur = "#aaaaee"} if( it < 20 ){couleur = "#f0f0f0"} if( it < 19 ){couleur = "#e0e0e0"} if( it < 18 ){couleur = "#d0d0d0"} if( it < 17 ){couleur = "#c0c0c0"} if( it < 16 ){couleur = "#b0b0b0"} if( it < 15 ){couleur = "#a0a0a0"} if( it < 14 ){couleur = "#909090"} if( it < 13 ){couleur = "#808080"} if( it < 12 ){couleur = "#707070"} if( it < 11 ){couleur = "#606060"} if( it < 10 ){couleur = "#505050"} if( it < 9 ){couleur = "#404040"} if( it < 8 ){couleur = "#303030"} if( it < 7 ){couleur = "#202020"} if( it < 6 ){couleur = "#101010"} if( it < 5 ){couleur = noir} point([x,y]) } }
Fractale de Julia Xmin = -1.6 Xmax = 1.6 Ymin = -1.6 Ymax = 1.6 trait = 0.3 couleur = noir cx = 0.35 cy = 0.08 itMax = 50 for(x= Xmin;x<=Xmax;x=x+(Xmax-Xmin)/400){ for(y=Ymin;y<=Ymax;y=y+(Ymax-Ymin)/400){ it = 0 tmp = x z_r = x z_i = y test = z_r*z_r+z_i*z_i while( test<4 && it<itMax ){ tmp = z_r z_r = z_r*z_r-z_i*z_i+cx z_i = 2*z_i*tmp + cy it++ test = z_r*z_r+z_i*z_i } if( it == itMax ){couleur = blanc} if( it < 45 ){couleur = "#d2d2ff"} if( it < 40 ){couleur = "#c6c6ff"} if( it < 35 ){couleur = "#b8b8ff"} if( it < 30 ){couleur = "#a7a7ff"} if( it < 25 ){couleur = "#9b9bff"} if( it < 22 ){couleur = "#9191ff"} if( it < 20 ){couleur = "#f0f0f0"} if( it < 19 ){couleur = "#e0e0e0"} if( it < 18 ){couleur = "#d0d0d0"} if( it < 17 ){couleur = "#c0c0c0"} if( it < 16 ){couleur = "#b0b0b0"} if( it < 15 ){couleur = "#a0a0a0"} if( it < 14 ){couleur = "#909090"} if( it < 13 ){couleur = "#808080"} if( it < 12 ){couleur = "#707070"} if( it < 11 ){couleur = "#606060"} if( it < 10 ){couleur = "#505050"} if( it < 9 ){couleur = "#404040"} if( it < 8 ){couleur = "#303030"} if( it < 7 ){couleur = "#202020"} if( it < 6 ){couleur = "#101010"} if( it < 5 ){couleur = noir} point([x,y]) } }
Une autre fractale de Julia

On peut modifier les valeur de cx et cy pour obtenir diverses fractales :
cx=0.35 et cy=0.08 cx=-0.25 et cy=0.65 cx=-0.28 et cy=0.635 cx=-0.745 et cy=0.12 cx=-0.55 et cy=0.54 cx=-0.545 et cy=0.51
Xmin = -1.5 Xmax = 1.5 Ymin = -1.5 Ymax = 1.5 trait = 0.3 couleur = noir cx = -0.745 cy = 0.12 N = 1 itMax = 200 for(x= Xmin;x<=Xmax;x=x+(Xmax-Xmin)/400){ for(y=Ymin;y<=Ymax;y=y+(Ymax-Ymin)/400){ it = 0 tmp = x z_r = x z_i = y test = z_r*z_r+z_i*z_i while( test<4 && it<itMax ){ tmp = z_r z_r = z_r*z_r-z_i*z_i+cx z_i = 2*z_i*tmp + cy it++ test = z_r*z_r+z_i*z_i } coul = 255*puissance(it/itMax,N) couleur = "rgb("+coul+","+coul+","+coul+")" point([x,y]) } }
Tri à bulles Xmin=0 Xmax=50 Ymin=0 Ymax=100 T = [100,53,77,12,5,148,11,34,86,17,98,3,50,53,0,28,94,51,48,25,6,54,61,60,78,99,12,41,33,47,54,8,5,47,26,58,11,31,54,37,82,47,42,25,18,26,12,43,68,71] i = T.length j = 0 trace(T) transparence = 1 bubble(T,i,j) function bubble(T,i,j){ if(i>0){ if(j < i-1){ inverse(T,j) setTimeout(function (){bubble(T,i,j+1)},50) } else{ j=0 setTimeout(function (){bubble(T,i-1,j)},50) } } trace(T) } function inverse(T,j){ if( T[j] > T[j+1] ){ x = T[j] T[j] = T[j+1] T[j+1] = x } } function trace(T){ couleur = blanc peinture = blanc transparence = 1 rectangle([0,100],50,100) couleur = noir for(i=0;i < T.length;i++){ peinture = bleu transparence = 0.5 rectangle([i,T[i]],1,T[i]) } }
Géométrie dans l'espace point([5,0,0]) point([0,0,0]) point([5,5,0]) point([0,5,0]) point([0,0,5]) point([5,0,5]) point([0,5,5]) point([5,5,5]) segment([5,0,0],[5,0,5]) segment([5,0,0],[5,5,0]) segment([5,0,5],[5,5,5]) segment([5,5,5],[0,5,5]) segment([5,5,5],[5,5,0]) segment([0,5,5],[0,5,0]) segment([5,5,0],[0,5,0]) segment([0,0,5],[5,0,5]) segment([0,0,5],[0,5,5]) segment([0,0,5],[0,0,0],[5,5]) segment([0,0,0],[0,5,0],[5,5]) segment([0,0,0],[5,0,0],[5,5]) triangle([0,0,5],[5,0,0],[0,5,0],[10,10]) texte("A",[0,0.3,0.2]) texte("B",[5,-0.8,-0.2]) droiteParam([0,0,0],[1,1,1])