Non tracé des discontinuités

[GM]

Comment peux-on définir une fonction affine par morceaux avec 3 branches par exemple ?

Avec deux tests... tout simplement... :

Code : Tout sélectionner

real f(real x) {return x <=1.5 ? ((x <=-0.5) ? -2 : -1) : 1;}

[maurice]

Oups, il y avait un problème !
Avec ça, c'est mieux.

*** Pour masquer/découvrir le code Asymptote qui a permis de créer la figure, il faut cliquer dessus. ;-) ***

CODE ASYMPTOTE de la figure ci-dessus : Tout sélectionner

 
import graph;
unitsize(1cm);
struct jump {
	  real x;
	  int i;
	  void operator init(real x, int i) {
	    this.x=x;
	    this.i=i;
	  }
}
void saut(real f(real x),jump ici, real a, real b, pen stylo=black) {
	  real epsi=0.001;
	  if (ici.i==1) {
	  	dot((ici.x,f(ici.x)),stylo);
	  	dot((ici.x,f(ici.x+epsi)),stylo,UnFill);
	  	draw(graph(f,a,ici.x,n=200),stylo);
	  	draw(graph(f,ici.x+epsi,b,n=200),stylo);
	  }
	  else {
	  	dot((ici.x,f(ici.x-epsi)),stylo,UnFill);
	  	dot((ici.x,f(ici.x)),stylo);
	  	draw(graph(f,a,ici.x-epsi,n=200),stylo);
	  	draw(graph(f,ici.x,b,n=200),stylo);
	  }
}
void multisaut(real f(real x),jump[] listedessauts, real a, real b, pen stylo=black) {
	  real epsi=0.001;
	  if (listedessauts[0].i==1) {
	  	dot((listedessauts[0].x,f(listedessauts[0].x)),stylo);
	  	dot((listedessauts[0].x,f(listedessauts[0].x+epsi)),stylo,UnFill);
	  	draw(graph(f,a,listedessauts[0].x,n=200),stylo);
	  }
	  else {
	  	dot((listedessauts[0].x,f(listedessauts[0].x-epsi)),stylo,UnFill);
	  	dot((listedessauts[0].x,f(listedessauts[0].x)),stylo);
	  	draw(graph(f,a,listedessauts[0].x-epsi,n=200),stylo);
	  }
	  for (int k=1; k<listedessauts.length; k+=1) {
	  	if (listedessauts[k].i==1) {
	  		dot((listedessauts[k].x,f(listedessauts[k].x)),stylo);
	  		dot((listedessauts[k].x,f(listedessauts[k].x+epsi)),stylo,UnFill);
	  		if (listedessauts[k-1].i==1) 
	  			draw(graph(f,listedessauts[k-1].x+epsi,listedessauts[k].x,n=200),stylo);
	  		else 
	  			draw(graph(f,listedessauts[k-1].x,listedessauts[k].x,n=200),stylo);
	  	}
	  	else {
		  	dot((listedessauts[k].x,f(listedessauts[k].x-epsi)),stylo,UnFill);
		  	dot((listedessauts[k].x,f(listedessauts[k].x)),stylo);
		  	if (listedessauts[k-1].i==1) 
			  	draw(graph(f,listedessauts[k-1].x+epsi,listedessauts[k].x-epsi,n=200),stylo);
			else 
				draw(graph(f,listedessauts[k-1].x,listedessauts[k].x-epsi,n=200),stylo);
	  	}
	  }
	  if (listedessauts[listedessauts.length-1].i==1)
		  draw(graph(f,listedessauts[listedessauts.length-1].x+epsi,b,n=200),stylo);
	  else 
	  	  draw(graph(f,listedessauts[listedessauts.length-1].x,b,n=200),stylo);
}
real f(real x) {return floor(x);}
jump[] listedessauts;
       listedessauts[0]=jump(-2,0);
       listedessauts[1]=jump(-1,0);
       listedessauts[2]=jump(0,0);
       listedessauts[3]=jump(1,0);
       listedessauts[4]=jump(2,0);
 
multisaut(f,listedessauts,-2.5,2.5,red);
 
// Définition de la fonction de Heaviside+0.5
real H(real t) {return (t < 0 ? 0 : 1)+0.5;}
jump pt=jump(0,0);
saut(H,pt,-2.5,2.5,blue);
 
//Fonction affine par morceaux
real G(real y) {return y <=-1 ? -y : 1.5*y-1.5;}
jump ici=jump(-1,1);
saut(G,ici,-2.5,2.5,green);
 
real m(real x) {return x <=1.5 ? ((x <=-0.5) ? -2 : -1) : 1;}
jump[] la;
       la[0]=jump(-0.5,1);
       la[1]=jump(1.5,1);
multisaut(m,la,-2.5,2.5,yellow);
 
xaxis(Arrow);
yaxis(Arrow);
 

Maurice

[jmbdeblois]

C'est chouette ce que tu as produit Maurice.
Pour les fonctions continues par morceaux, la fonction de Heaviside est faite pour cela.(ou alors je n'ai pas compris ta remarque sur les fonctions ayant trois branches !)
Essaye ceci :

Code : Tout sélectionner

// 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)-2*H(t-pi/2)+H(t-pi);}

J'ai repris ta foction pointparpoint et c'est parfait. Sauf que je dois peaufiner pour faire apparaitre les exclusions inclusions de points aux bords des discontinuité.