Page 1 sur 1

Somme des cubes

Posté : lun. 8 mars 2010, 10:27
par OG

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.

Re: Somme des cubes

Posté : mar. 16 mars 2010, 12:21
par mumblee
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.

Re: Somme des cubes

Posté : mar. 16 mars 2010, 13:39
par OG
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.