Discussion :

[NicoV]

Un petit truc aussi pour aller 2 fois plus vite: il y a des chances que l'interaction d'une particule a sur une particule b soit la même au signe près de b sur a. Donc pas la peine de la calculer dans les 2 sens.

Autre idée: vérifie que tu ne crée pas de variable temporaire dans ta fonction de mise à jour. Les allocations mémoire + Garbage Collector peuvent faire mal.

[piteon]

Merci pour tous vos commentaires.
Tous ont l'air interessants , il va me falloir un moment pour implementer tout ça mais je reviendrais bientot vous dire quelles solutions ont le mieux marchées.
Merci encore à bientot

[piteon]

nicoV > Des variables temporaires, j'en crée des disaines dans la fonction de mise à jour. Mais c'est indispensable , non ? Il vaut mieux que je les passe en attribut de ma classe plutot ? Ca changera vraiment quelque chose ?

[®om]

nicoV > Des variables temporaires, j'en crée des disaines dans la fonction de mise à jour. Mais c'est indispensable , non ? Il vaut mieux que je les passe en attribut de ma classe plutot ? Ca changera vraiment quelque chose ?

Non, il vaut mieux les laisser en locales...

Ce qu'il voulait dire, je pense, c'est d'instancier des objets à chaque tour de boucle si tu n'es pas obligé...

[In Vino Veritas]

Bonjour Piteon,

tu pourrais peut-être aussi utiliser un tableau de correspondance [x, exp(x)] qui te permettrait de remplacer le calcul systématique de exp(x) par simplement une lecture dans un tableau, créé une bonne fois pour toutes et stocke en mémoire. Cela introduit certes une approximation, mais pas forcément plus importante que celle réalisée en négligeant l'influence des particules les plus lointaines, si le "pas" de ton tableau est suffisamment fin. Par contre, je pense que cela peut réduire le temps de calcul de beaucoup, si j'en crois le nombre d'appels à la fonction exponentielle que tu réalises.

Je ne sais pas du tout si le calcul d'un carré est couteux en temps de calcul, mais si c'est le cas, tu peux aussi appliquer cette méthode pour le calcul des distances entre particules (calculer (x2-x1)^2 + (y2-y1)^2 après avoir regardé les valeurs de (x2-x1)^2 et de (y2-y1)^2 dans un tableau de correspondance de type [x,x^2].

Tiens-nous au courant de ton avancée, et de ce qui marche ou ne marche pas! Bon courage!

In Vino Veritas

[NicoV]

C'est à peu près çà.

Avec 1000 particules, tu appelles 1000 fois miseAJour() qui doit ressembler à çà:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
Pour chaque particule
   Calcul de la contribution de la particule
Fin Pour
Calcul du nouvel état de la particule

Evite au maximum de faire des new dans le Pour (le code à l'intérieur est appelé 1 million de fois pour chaque pas de temps), et éventuellement dans le reste de la méthode miseAJour().

Pour un programme graphique sur lequel j'ai travaillé (représentation en 3D de molécules), on était allé jusqu'à supprimer tous les new dans les méthodes utilisées pendant le dessin (quitte à passer par des attributs) pour éviter d'avoir des déclenchements de GC.

Elle est vraiment grosse ta méthode miseAJour() ? Si elle est raisonnable, tu peux toujours nous la montrer.

[anadoncamille]

Bonjour,

je fais du jeu vidéo en Java, dont un actuellement (http://www.anadoncamille.com/) et j'aime les simulations de vie.

Donc je travaille régulièrement avec des milliers d'individus (cf LoveDrake dans AnAcondA). Là tu te retrouves avec un problème de gestion de voisinage, tu as un moteur de collisions à faire.

=====

Une optimisation qui te feras gagner du temps est le découpage par zones. Dans un extrême tu fais une zone comme avant et dans l'autre tu en fais plein de minuscules. Plus la zone type de ton découpage est petite, moins tu auras de voisins à traiter, mais plus tu auras de zones à calculer.

Tu dois étudier la case de la particules et ses voisines directes, pour éviter les effets de bords. Ces effets se manifestent quand deux particules voisines ne sont pas traitées comme voisines car sur deux zones différentes alors qu'elles devraient être traitées comme des voisines. C'est pourquoi dans le découpage par zone, tu traites chaque case et ses 8 voisines.

Chaque zone peut contenir x particules. Il te font donc dans chaque zone un vecteur "liste de particules" que tu tiens à jour pour tout déplacement.

Tu fais la liste des voisins de ta particule en ajoutant la liste des voisins de la case de ta particule, plus la liste des particules des 8 cases voisines.
Après tu fais tes calculs de distance et de répulsion sur cette liste réduite.

Voilà pour les zones.

=====

Pour les calculs, les tables de mémorisation f[x] = r sont les plus performantes.
Si ta fonction est bornée en entrée, c'est à dire que A <= x <= B, c'est idéal et tu peux choisir la taille de ton tableau, stocker les calculs et voir la différence. Peut être que cette optimisation t'épargnera la précédente.

Si ta fonction n'est pas bornée, c'est autre chose, peux-tu la segmenter, l'approximer dans certaines zones?

Bonne optimisation !

[anadoncamille]

En repensant aux fonctions précalculable, je ne connais pas la forme de ta fonction, mais si elle est périodique, comme sin(a) tu peux faire quelque chose dans ce style : http://www.developpez.net/forums/sho...79#post2372879