Somme des cubes

Règles du forum
ATTENTION ! Il est demandé de ne déposer dans ce forum que des exemples en langage Asymptote
  • finalisés
  • que l'on pense intéressants et optimisés
  • et qui se rapportent au thème du forum.
Si certains exemples déposés donnent lieu à de nombreuses modifications, ils seront déplacés et remplacés par un nouveau sujet dans ce forum avec la ou les meilleures propositions.
Pour les demandes d'aide ... il y a un forum spécifique !
OG
V.I.P.
V.I.P.
Messages : 134
Enregistré le : dim. 7 mars 2010, 22:27

Somme des cubes

Message non lu par OG » lun. 8 mars 2010, 10:27

Figure asymptote 4bbeb2bf7d5c3cc6af5fd941b92b5ffa
*** 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
  1. size(200,0);
  2. import patterns;
  3.  
  4. add("hatch",hatch(2mm));
  5. add("hatchback",hatch(2mm,NW));
  6. add("crosshatch",crosshatch(2mm));
  7.  
  8. path p=unitsquare;
  9.  
  10. for(int i=0;i<15;++i)
  11. {
  12. for (int j=0;j<15;++j)
  13. {
  14. draw(shift(i,j)*p);
  15. }
  16. }
  17.  
  18. filldraw(p,gray);
  19. path p1=scale(2)*p;
  20. filldraw(shift(0,1)*p1,pattern("hatch"));
  21. filldraw(shift(1,0)*p1,pattern("hatch"));
  22. filldraw(shift(1,1)*p,pattern("crosshatch"));
  23.  
  24. path p2=scale(3)*p;
  25. filldraw(shift(3,0)*p2,gray);
  26. filldraw(shift(3,3)*p2,gray);
  27. filldraw(shift(0,3)*p2,gray);
  28.  
  29.  
  30. path p3=scale(4)*p;
  31. filldraw(shift(6,0)*p3,pattern("hatch"));
  32. filldraw(shift(4,6)*p3,pattern("hatch"));
  33. filldraw(shift(0,6)*p3,pattern("hatch"));
  34.  
  35. filldraw(shift(6,4)*p3,pattern("hatch"));
  36. filldraw(shift(6,6)*p1,pattern("crosshatch"));
  37. filldraw(shift(8,8)*p1,white);
  38.  
  39.  
  40.  
  41. path p4=scale(5)*p;
  42. filldraw(shift(10,0)*p4,gray);
  43. filldraw(shift(10,5)*p4,gray);
  44. filldraw(shift(0,10)*p4,gray);
  45. filldraw(shift(10,10)*p4,gray);
  46. filldraw(shift(5,10)*p4,gray);
  47.  
  48. for(int i=0;i<15;++i)
  49. {
  50. for (int j=0;j<15;++j)
  51. {
  52. draw(shift(i,j)*p);
  53. }
  54. }
  55. filldraw(shift(8,8)*p1,white);
  56.  
  57. draw(p,black+1.5bp);
  58. draw(scale(3)*p,black+1.5bp);
  59. draw(scale(6)*p,black+1.5bp);
  60. draw(scale(10)*p,black+1.5bp);
  61.  
  62. draw(scale(15)*p,black+1.5bp);



Permet en clignant des yeux de trouver la formule 1^3+2^3+3^3+4^3+\cdots+n^3.

mumblee
Messages : 34
Enregistré le : jeu. 11 mars 2010, 10:29
Localisation : Lille

Re: Somme des cubes

Message non lu par mumblee » mar. 16 mars 2010, 12:21

Tu n'utilises pas le motif hatchback défini, dommage parce que je trouve qu'on cligne mieux des yeux si les pavés "verticaux" sont remplis avec hatch et les "horizontaux" avec hatchback. Du coup, avec la superposition, pas besoin du motif crosshatch.

Bref, je propose une variante du code (avec en plus, n qui vaut ce qu'on veut ;) )

Code : Tout sélectionner

unitsize(0.5cm);
import patterns;

// choisir un entier n
int n=5;

// motifs
add("hatch",hatch(2mm));
add("hatchback",hatch(2mm,NW));

// sommes des k premiers entiers ( 1<= k <=n )
int sum(int n) {
  real somme=n*(n+1)/2;
  return (int) somme;
}
int[] s;
for(int i=0;i<=n;++i) {
  s[i]=sum(i);
}

// pavés
path[] p;
for(int i=1;i<=n;++i) {
  p[i]=scale(i)*unitsquare;
}

// fond
filldraw(scale(s[n],s[n])*unitsquare,white);

// affichage des pavés
for(int i=1;i<=n;++i) {
  if (i%2 == 0) {
    // cas pair
    for(int j=0;j<(i-1)/2;++j) {
      filldraw(shift(s[i-1],i*j)*p[i],pattern("hatch"),black+0.75bp);
      filldraw(shift(i*j,s[i-1])*p[i],pattern("hatchback"),black+0.75bp);
    }
  } else {
    // cas impair
    for(int j=0;j<(i-1)/2;++j) {
      filldraw(shift(s[i-1],i*j)*p[i],gray,black+0.75bp);
      filldraw(shift(i*j,s[i-1])*p[i],gray,black+0.75bp);
    }
    filldraw(shift(i*(i-1)/2,i*(i-1)/2)*p[i],gray,black+0.75bp);
  }
}

// quadrillage
for(int i=0;i<s[n];++i) {
  for (int j=0;j<s[n];++j) {
    draw(shift(i,j)*p[1],currentpen+0.25bp);
  }
}

// blocs
for(int i=1;i<=n;++i) {
  draw(scale(s[i])*p[1],currentpen+1.5bp);
}

Il y a une partie au début qu'on peut simplifier, mais ça donne un exemple de fonction avec un cast explicite real->int.
Fabrice Eudes

OG
V.I.P.
V.I.P.
Messages : 134
Enregistré le : dim. 7 mars 2010, 22:27

Re: Somme des cubes

Message non lu par OG » mar. 16 mars 2010, 13:39

mumblee a écrit :Tu n'utilises pas le motif hatchback défini, dommage parce que je trouve qu'on cligne mieux des yeux si les pavés "verticaux" sont remplis avec hatch et les "horizontaux" avec hatchback. Du coup, avec la superposition, pas besoin du motif crosshatch.

Bref, je propose une variante du code (avec en plus, n qui vaut ce qu'on veut ;) )


Merci pour l'amélioration du code. J'avais tapé le matin pour le jour même tous
ces trucs de somme et une ou deux figures en plus (pour occuper une classe de
seconde dans le cadre d'un parrainage "classe+enseignant+chercheur").
Et comme je code naturellement comme un goret...

Voici ce que cela donne, effectivement hatch et hatchback rendent la figure
encore plus lisible.
O.G.

Figure asymptote 0651d89b0193e4ba54cd2ca6b3da0f83
*** 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
  1.  
  2. unitsize(0.5cm);
  3. import patterns;
  4.  
  5. // choisir un entier n
  6. int n=5;
  7.  
  8. // motifs
  9. add("hatch",hatch(2mm));
  10. add("hatchback",hatch(2mm,NW));
  11.  
  12. // sommes des k premiers entiers ( 1<= k <=n )
  13. int sum(int n) {
  14. real somme=n*(n+1)/2;
  15. return (int) somme;
  16. }
  17. int[] s;
  18. for(int i=0;i<=n;++i) {
  19. s[i]=sum(i);
  20. }
  21.  
  22. // pavés
  23. path[] p;
  24. for(int i=1;i<=n;++i) {
  25. p[i]=scale(i)*unitsquare;
  26. }
  27.  
  28. // fond
  29. filldraw(scale(s[n],s[n])*unitsquare,white);
  30.  
  31. // affichage des pavés
  32. for(int i=1;i<=n;++i) {
  33. if (i%2 == 0) {
  34. // cas pair
  35. for(int j=0;j<(i-1)/2;++j) {
  36. filldraw(shift(s[i-1],i*j)*p[i],pattern("hatch"),black+0.75bp);
  37. filldraw(shift(i*j,s[i-1])*p[i],pattern("hatchback"),black+0.75bp);
  38. }
  39. } else {
  40. // cas impair
  41. for(int j=0;j<(i-1)/2;++j) {
  42. filldraw(shift(s[i-1],i*j)*p[i],gray,black+0.75bp);
  43. filldraw(shift(i*j,s[i-1])*p[i],gray,black+0.75bp);
  44. }
  45. filldraw(shift(i*(i-1)/2,i*(i-1)/2)*p[i],gray,black+0.75bp);
  46. }
  47. }
  48.  
  49. // quadrillage
  50. for(int i=0;i<s[n];++i) {
  51. for (int j=0;j<s[n];++j) {
  52. draw(shift(i,j)*p[1],currentpen+0.25bp);
  53. }
  54. }
  55.  
  56. // blocs
  57. for(int i=1;i<=n;++i) {
  58. draw(scale(s[i])*p[1],currentpen+1.5bp);
  59. }
  60.  

Répondre