ASY-Forum dédié à Asymptote

[jmbdeblois]

Bonjour, j'ai repris l'exemple de Heaviside pour tracer une fonction f dont je joins le code, mais il y a le tracé de la discontinuité en x=2. Je n'ai pas du tout comprendre au booléen censé l'en empêcher !
Où est mon erreur alors ?

Code: Tout sélectionner

import graph;
size(300);

real xmin=-3,xmax=3;
real ymin=-1,ymax=2;

// Test pour savoir s'il faut relier les points ou pas lors de l'utilisation de graph.
bool3 condition(real x)
{
  static int derniersigne=0;
  int signe = sgn(x);
  bool b = derniersigne == 0 || signe == derniersigne;
  derniersigne = signe;
  return b ? true : default;
}

// Définition de la fonction de Heaviside
real H(real t) {return t < 0 ? 0 : 1;}
// Définition de la fonction
real f(real t){ return t*H(t)-(t-1)*H(t-1)-H(t-2);}

// Tracé de la courbe
guide[] CH=graph(f,xmin,xmax,condition,n=400);
draw(CH,1.5bp+blue);

real margeaxe=.4;
xaxis(Label("$x$",align=Align),xmin-margeaxe,xmax+margeaxe,Ticks(NoZero),Arrow);
yaxis(ymin-margeaxe,ymax+margeaxe,Ticks(NoZero),Arrow);

shipout(bbox(2mm,Fill(white)));

[maurice]

Bonjour,

en remplaçant

Code: Tout sélectionner

int signe = sgn(x);

par

Code: Tout sélectionner

int signe = sgn(x-2);

ça marche.

Code: Tout sélectionner

// Test pour savoir s'il faut relier les points ou pas lors de l'utilisation de graph.
bool3 condition(real x)
{
  static int derniersigne=0;
  int signe = sgn(x-2);
  bool b = derniersigne == 0 || signe == derniersigne;
  derniersigne = signe;
  return b ? true : default;
}

Par contre pour les explications, faudra attendre le maître.
J'ai fait ca à l'intuition.

Maurice

[jmbdeblois]

Bien sûr, que je suis ballot. Merci Maurice.
EN fait le test sert à ne pas tracer les discontinuités là ou il y a des discontinuités !
Faudrait bosser sur ce booléen pour qu'il les repère systématiquement. Car s'il y en a deux, comme dans le cas d'un signal carré...

[GM]

Faudrait bosser sur ce booléen pour qu'il les repère systématiquement.

Houla... pas facile cela.
J'en veux pour preuve que, si c'était un problème facile... les calculatrices sauraient les gérer or, bien souvent, elles tracent des traits verticaux abusifs reliant des branches qu'elles ne devraient pas relier.

Personne ne connait un des concepteurs de geogebra ou d'un autre grapheur pour savoir comment ils font ?

[jmbdeblois]

Houla... pas facile cela.
J'en veux pour preuve que, si c'était un problème facile... les calculatrices sauraient les gérer or, bien souvent, elles tracent des traits verticaux abusifs reliant des branches qu'elles ne devraient pas relier.

L'idée que j'avais déjà programmée il y a quelques temps, est de tester la différence entre deux ordonnées consécutives dans le tracé par segment de f. Si la valeur absolue de la différence est supérieur à un certain epsilon prévu à l'avance, on ne trace pas la fonction. On saute d'un point à l'autre, sans tracer le segment entre ces deux points.
L'écueil est sur les fonctions présentant des variations très fortes (comme exp). Mais ça marchait pas trop mal.

[maurice]

Bonjour,

Et pourquoi pas un tracé point par point ?

Code: Tout sélectionner

import graph;

//Taille de l'image
size(500);

//Tracé de la courbe point par point
void pointparpoint(real f(real x), real a, real b, int n, pen stylo=black) {
      real[] A=new real[n+1];
      real[] B=new real[n+1];
      real w=linewidth();
      for (int k=0; k<=n; ++k) {
         A[k]=a+k*((b-a)/n);
         B[k]=f(a+k*((b-a)/n));
         dot((A[k],B[k]),stylo+2w);
      }
}

//Définition de la fonction
real f(real x) {return floor(x);}
real g(real x) {return exp(x);}

xaxis(Ticks(NoZero),Arrow);
yaxis(Ticks(NoZero),Arrow);
pointparpoint(f,-3,3,600,red);
pointparpoint(g,-3,log(3),1000,green);

Effectivement pour l'exponentielle, n doit devenir "gran".

Maurice

[jmbdeblois]

C'est pas mal du tout ça !
Effectivement, du coup les discontinuités sont presque évacuées.
J'essaye de ce pas !

[jmbdeblois]

Voici ce que cela donne :

Code: Tout sélectionner

import graph;
import patterns;
usepackage("mathrsfs");

unitsize(2cm,2cm);
real xmin=-1,xmax=4;
real ymin=-1.5,ymax=1.5;

// Définition de la fonction de Heaviside
real H(real t) {return t < 0 ? 0 : 1;}
// Définition de la fonction
real f(real t){ return H(t)-(t-1)*H(t-1)+(t-2)*H(t-2);}
real g(real t){ return -H(t-1)+H(t-2);}


xlimits(xmin,xmax,Crop);
ylimits(ymin,ymax,Crop);

// The grid :
xaxis(BottomTop, xmin, xmax, Ticks("%", Step=1, step=0.5, extend=true, ptick=lightgrey));
yaxis(LeftRight, ymin, ymax, Ticks("%", Step=1, step=0.5, extend=true, ptick=lightgrey));
// The axis.
xequals(Label("$y$",align=W),0,ymin=ymin-0.25, ymax=ymax+0.25,
        Ticks(NoZero,pTick=nullpen, ptick=grey),
        p=linewidth(1pt), Arrow(2mm));
yequals(Label("$x$",align=S),0,xmin=xmin-0.25, xmax=xmax+0.25,
        Ticks(NoZero,pTick=nullpen, ptick=grey),
        p=linewidth(1pt), Arrow(2mm));

labelx(Label("$O$",NoFill), 0, SW);
draw(Label("$\vec{\imath}$",align=S,UnFill),
     (0,0)--(1,0),scale(2)*currentpen,Arrow);
draw(Label("$\vec{\jmath}$",align=W,UnFill),
     (0,0)--(0,1),scale(2)*currentpen,Arrow);
dot((0,0));

label("$\mathscr{C}_f$",(1.5,f(1.5)),2N,red);
label("$\mathscr{C}_f'$",(1.5,g(1.5)),2S,green);

//Tracé de la courbe point par point
void pointparpoint(real f(real x), real a, real b, int n, pen stylo=black) {
      real[] A=new real[n+1];
      real[] B=new real[n+1];
      real w=linewidth();
      for (int k=0; k<=n; ++k) {
         A[k]=a+k*((b-a)/n);
         B[k]=f(a+k*((b-a)/n));
         dot((A[k],B[k]),stylo+2w);
      }
}

pointparpoint(f,-1,3,600,red);
pointparpoint(g,0,3,600,green);

[OG]

Bonsoir

Pour faire quelque chose d'efficace et rapide qui détecte tous les points de discontinuité
cela ne doit pas être coton et il y aura toujours des faux positifs ou des vrais négatifs.

Une solution intermédiaire serait déjà de pouvoir donner une liste (finie) des points de discontinuité.

O.G.

[projetmbc]

Personne ne connait un des concepteurs de geogebra ou d'un autre grapheur pour savoir comment ils font ?

La seule technique que je connaisse est de travailler avec un seuil d'acceptation des segments verticaux reliant deux points consécutifs du tracé de la courbe d'équation cartésienne.

L'idée d'indiquer à la main les points de discontinuité est une très bonne idée aussi.