ASY-Forum dédié à Asymptote

[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.

Code: 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é.