Bonjour,

Dans le cadre de mon apprentissage du langage C je souhaite écrire un programme me permettant de determiner les trajectoires périodiques dans un billard de forme quelconque.
Ce que j'appelle trajectoire est la donnée des coordonnées des points situés sur la bande.
Pour ce qui est des mathématiques je me sers du poly suivant : http://www.numdam.org/article/TSG_19...3__1__A3_0.pdf .

Pour résumer rapidement, une trajectoire est périodique si et seulement si les dérivées de la longueur totale de la trajectoire par rapport à chacun des angles est nulles.

Ainsi je dispose de plusieurs fonctions : ( mes points sont définis avec des coordonnées polaire .. )

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
 
double Li(double theta1, double theta2, double a, double b) // Calcule la longueur de la section entre les deux points en paramètre ( a et b sont des constantes du problème ... )
{
  double rho1 = rho(a,b,theta1); // on fait le passage en cartésien
  double rho2 = rho(a,b,theta2);
  double x1 = rho1*cos(theta1);
  double y1 = rho1*sin(theta1);
  double x2 = rho2*cos(theta2);
  double y2 = rho2*sin(theta2);
  return sqrt(pow(x1-x2,2)+pow(y1-y2,2)); // Pythagore pour avoir la longeur du segment
}
 
double dli_dsi(double *Theta, double L, double a, double b,int i,double ds,int n) // On calcule la dérivée par rapport à l'angle. ( n = nombre de points ) 
{
  double AncienTheta = Theta[i];
  Theta[i] += ds; // ds est un angle infinitésimale ( je le prends égale à 1e-4 ... )
  double L_di = l(Theta,n,a,b);
  Theta[i] = AncienTheta;
  return (L_di - L)/ds; // ((f(a+h) - f(a))/h ...
}
 
double Xhi(double *Theta, double a, double b, double n, double ds) // Fonction qui calcule finalement la somme des dérivées au carré pour obtenir une sorte de fonction d'erreur ...
{
  double somme = 0;
  double L = l(Theta,n,a,b);
  for(int i=0;i<n; i++)
  {
        somme += pow(dli_dsi(Theta,L,a,b,i,ds,n),2);
  }
  return somme;
}
Ensuite pour essayer de minimiser la la valeur de Xhi je commence par générer un tableau avec N angles et ensuite je calcule la valeur de Xhi pour ce tableau. Ensuite, je me donne aléatoirement des tableaux contenant des valeurs d'angles et je compare la valeur de Xhi avec la valeur précédente et je fais ça environ 200.000 fois et je garde le tableau m'ayant donné la plus petite valeur de Xhi.

voici le code qui correspond à cette partie :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
Generation(Theta,n); // Renvoie un tableau avec n angles.
 
  double sum = Xhi(Theta,a,b,n,ds);
  double check;
 
  // On cherche les points qui minimisent le sum
 
  for(int j = 0; j<N;j++)
  {
    Generation(ThetaBis,n);
    check = Xhi(ThetaBis,a,b,n,ds);
 
    if(check < sum)
    {
      sum = check;
      Theta = ThetaBis;
      cout << " check : " << check << endl; // Pour être sur que la valeur du sum diminue effectivement.
    }
  }
Cependant lorsque j'exporte les valeurs dans un fichier et que je plot avec python les trajectoires sont tout sauf périodique et je désespère de ne pas savoir pourquoi.
Si une âme charitable pourrait m'apporter un coup de pouce je lui en serrai reconnaissant.

Merci d'avance.