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([[-5,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 --> la couleur de remplissage est transparente.
transparence = 1 --> 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      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    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       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       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])