Les agités du bocal

sergio wrote:

Bonjour,

je souhaiterais représenter l'agitation moléculaire de particules
gazeuses dans un bocal.
Pour cela, sur un picturebox, je dessine une série de cercles
représentant les molécules. J'ai créé ainsi une collection de
particules définies par ses coordonnées (x,y), sa vitesse et sa
direction (par un angle).

Al'aide d'un controle Timer, tous les 100ms, les paramètres de chaque
particule sont recalculés et les particules redessinées sur le
picturebox.

De plus, Je dois vérifier que la position d'une particule ne recouvre
pas celle d'une autre particule. Je prends donc en compte les chocs
entre particules une à une.
Vous voyez la procédure est un peu longue en temps car il y a
beaucoup de calculs.

Existerait-il une méthode plus simple pour cela, sans forcément
passer par une collection et être obligé de calculer un à un tous les
paramètres afin que l'animation soit plus fluide également ?

Merci pour votre aide.
Sincères salutations à tous.

Hello,

pour la partie tracé graphique, je te conseille de regarder du coté de
GDI+, le seul moyen de faire des choses vraiment fluides. Un bon
article d'introduction:
http://visualbasic.about.com/od/usingvbnet/a/GDIPlus03.htm

Des choses à voir ici également:
http://www.codeguru.com/vb/gen/vb_graphics/

El alors ici, du code d'excellente facture (salut Renfield!):
http://www.vbfrance.com/codes/EXEMPLE-UTILISATION-GDI-DANS-VB6_39804.aspx

Pour la partie calcul, difficile de dire ce qu'on peut améliorer.
On ignore ce que tu calcules, comment, etc.

Ce que je peux dire, c'est que les collections ne sont pas très efficaces en
terme
de performance pour l'accès aux données, des tableaux dynamiques seraient
plus efficaces.
Maintenant, si l'accès aux données représente peu par rapport à la masse des
calculs, ça n'a sans doute pas d'importance.

Pour les calculs eux-même, mes cours de physique sont loin mais je pense
que si tu peux "ordonner" tes particules, alors tu dois peut être pouvoir
éviter de
calculer certaines interactions, si à partir d'un certain point tu peux
être sur que les points suivants sont trop éloignés et donc n'interagissent
plus
de façon significative avec le suivants. Dans mes souvenirs, les forces en
présence sont en 1/R³, donc ça décroit extrèmement vite.
Ca suppose d'avoir une façon efficace de trier ou d'ordonner d'une
manière ou d'une autre tes particules.
Pour l'aspect tri, même si je doute que se soit adapté directement, voici
tout de même un lien vers l'article de la FAQ sur les tris:
http://faq.vb.free.fr/index.php?question1

<hs>
Je suppose que tes particules sont définies par leurs coordonnées
dans l'espace, donc en 3D. Il y a des méthodes assez efficace
pour déterminer heuristiquement les distances. Notamment en faisant
des projections en plan, on peut se ramener à trier les points sur
un seul axe, ce qui redevient un problème très simple. Ce n'est pas
optimal, ce n'est que heuristique, mais si ca permet déjà d'éliminer
à coup sur disons la motié des particules, comme les calculs d'interactions
entre n particlues exigent plus ou moins [(n)(n-1)]/2 calculs, une
diminution
de n d'un facteur 2 te fait gagner un facteur 4 en terme de nombres de
calculs. Perso, je chercherais dans cette voie.
</hs>

Avec une meilleure description du problème, on pourrait peut être
amener plus de solutions :-)

--
Jean-marc Noury (jean_marc_n2)
Microsoft MVP - Visual Basic
FAQ VB: http://faq.vb.free.fr/
mailto: remove '_no_spam_' ; _no_spam_jean_marc_n2@yahoo.fr

Rebonjour,

tout d'abord merci Jean-Marc pour ces premières pistes.
J'utilise VB5, et je ne sais pas si je peux utiliser le GDI+ ... que
d'ailleurs je ne connais pas. Faut-il installer un logiciel spécial ?

Mon problème est en fait trés simple puisqu'il s'agit uniquement d'un
problème en 2 dimensions (en non en 3D). Mes particules s'entrechoquent comme
des boules de billard. Donc point des forces en 1/r2 et d'interactions à
distance. Uniquement de la conservation de quantité de mouvement. Ce qui
reste simple en calcul. Tous les 100 ms, je recalcule la position en x,y de
toutes mes particules connaissant leur vitesse et leur direction.
Qu'appelez-vous des tableaux dynamiques ?

Merci encore pour votre aide.

Salutations.

"Jean-marc" a écrit :

sergio wrote:
> Bonjour,
>
> je souhaiterais représenter l'agitation moléculaire de particules
> gazeuses dans un bocal.
> Pour cela, sur un picturebox, je dessine une série de cercles
> représentant les molécules. J'ai créé ainsi une collection de
> particules définies par ses coordonnées (x,y), sa vitesse et sa
> direction (par un angle).
>
> Al'aide d'un controle Timer, tous les 100ms, les paramètres de chaque
> particule sont recalculés et les particules redessinées sur le
> picturebox.
>
> De plus, Je dois vérifier que la position d'une particule ne recouvre
> pas celle d'une autre particule. Je prends donc en compte les chocs
> entre particules une à une.
> Vous voyez la procédure est un peu longue en temps car il y a
> beaucoup de calculs.
>
> Existerait-il une méthode plus simple pour cela, sans forcément
> passer par une collection et être obligé de calculer un à un tous les
> paramètres afin que l'animation soit plus fluide également ?
>
> Merci pour votre aide.
> Sincères salutations à tous.

Hello,

pour la partie tracé graphique, je te conseille de regarder du coté de
GDI+, le seul moyen de faire des choses vraiment fluides. Un bon
article d'introduction:
http://visualbasic.about.com/od/usingvbnet/a/GDIPlus03.htm

Des choses à voir ici également:
http://www.codeguru.com/vb/gen/vb_graphics/

El alors ici, du code d'excellente facture (salut Renfield!):
http://www.vbfrance.com/codes/EXEMPLE-UTILISATION-GDI-DANS-VB6_39804.aspx

Pour la partie calcul, difficile de dire ce qu'on peut améliorer.
On ignore ce que tu calcules, comment, etc.

Ce que je peux dire, c'est que les collections ne sont pas très efficaces en
terme
de performance pour l'accès aux données, des tableaux dynamiques seraient
plus efficaces.
Maintenant, si l'accès aux données représente peu par rapport à la masse des
calculs, ça n'a sans doute pas d'importance.

Pour les calculs eux-même, mes cours de physique sont loin mais je pense
que si tu peux "ordonner" tes particules, alors tu dois peut être pouvoir
éviter de
calculer certaines interactions, si à partir d'un certain point tu peux
être sur que les points suivants sont trop éloignés et donc n'interagissent
plus
de façon significative avec le suivants. Dans mes souvenirs, les forces en
présence sont en 1/R³, donc ça décroit extrèmement vite.
Ca suppose d'avoir une façon efficace de trier ou d'ordonner d'une
manière ou d'une autre tes particules.
Pour l'aspect tri, même si je doute que se soit adapté directement, voici
tout de même un lien vers l'article de la FAQ sur les tris:
http://faq.vb.free.fr/index.php?question1

<hs>
Je suppose que tes particules sont définies par leurs coordonnées
dans l'espace, donc en 3D. Il y a des méthodes assez efficace
pour déterminer heuristiquement les distances. Notamment en faisant
des projections en plan, on peut se ramener à trier les points sur
un seul axe, ce qui redevient un problème très simple. Ce n'est pas
optimal, ce n'est que heuristique, mais si ca permet déjà d'éliminer
à coup sur disons la motié des particules, comme les calculs d'interactions
entre n particlues exigent plus ou moins [(n)(n-1)]/2 calculs, une
diminution
de n d'un facteur 2 te fait gagner un facteur 4 en terme de nombres de
calculs. Perso, je chercherais dans cette voie.
</hs>

Avec une meilleure description du problème, on pourrait peut être
amener plus de solutions :-)

--
Jean-marc Noury (jean_marc_n2)
Microsoft MVP - Visual Basic
FAQ VB: http://faq.vb.free.fr/
mailto: remove '_no_spam_' ; _no_spam_jean_marc_n2@yahoo.fr

sergio wrote:

Rebonjour,

tout d'abord merci Jean-Marc pour ces premières pistes.
J'utilise VB5, et je ne sais pas si je peux utiliser le GDI+ ... que
d'ailleurs je ne connais pas. Faut-il installer un logiciel spécial ?

Non, c'est juste un enxemble d'API. Voir les liens donnés
précédemment.

Mon problème est en fait trés simple puisqu'il s'agit uniquement d'un
problème en 2 dimensions (en non en 3D). Mes particules
s'entrechoquent comme des boules de billard. Donc point des forces en
1/r2 et d'interactions à distance. Uniquement de la conservation de
quantité de mouvement. Ce qui reste simple en calcul. Tous les 100
ms, je recalcule la position en x,y de toutes mes particules
connaissant leur vitesse et leur direction. Qu'appelez-vous des
tableaux dynamiques ?

Les tableaux dynamiques, c'est expliqué dans notre FAQ:
http://faq.vb.free.fr/index.php?question3

Bonne suite!

--
Jean-marc Noury (jean_marc_n2)
Microsoft MVP - Visual Basic
FAQ VB: http://faq.vb.free.fr/
mailto: remove '_no_spam_' ; _no_spam_jean_marc_n2@yahoo.fr

Bonjour,

Comme Jean-Marc je vous conseil les API graphiques pour la fluidité et
la possibilité de gérer le déplacement des particules de façon
transparente (on ne redessine que les particules pas le bocal). Par
contre je préconise GDI qui est plus ancienne mais qui est robuste et
efficace.

Concernant les calculs d'intersections, un cercle (comme nombre de
figure géomètrique) est inscrit dans un rectangle (et pour ce cas
particulier un carré). Savoir si deux rectangles ont une intersection
non vide est simple et rapide. si l'intersection est vide pas de calcul,
si non calcul de l'intersection réelle, si elle existe calcul du choc et
des nouvelles trajectoires.

Je vous joins la classe RealRegion que j'ai écrite pour gérer les
"rectangles".

A+

Christophe

Option Explicit
Private mLeft As Double
Private mRight As Double
Private mBottom As Double
Private mTop As Double
Private mColor As Long

Public Property Get Color() As Long

Color = mColor

End Property

Public Property Let Color(ByVal Color As Long)

mColor = Color

End Property




Public Property Get Left() As Double

Left = mLeft

End Property

Public Property Let Left(ByVal Left As Double)

mLeft = Left


End Property

Public Property Get Right() As Double


Right = mRight



End Property

Public Property Let Right(ByVal Right As Double)

mRight = Right



End Property

Public Property Get Bottom() As Double

Bottom = mBottom

End Property

Public Property Let Bottom(ByVal Bottom As Double)

mBottom = Bottom


End Property

Public Property Get Top() As Double

Top = mTop

End Property

Public Property Let Top(ByVal Top As Double)

mTop = Top


End Property



Public Function Intersection(r As RealRegion) As RealRegion
Dim Inter As RealRegion
Dim t As Double


Set Inter = New RealRegion



If mLeft < r.Left Then
If mRight < r.Left Then

Inter.Bottom = 0
Inter.Left = 0
Inter.Right = 0
Inter.Top = 0
Set Intersection = Inter
Set Inter = Nothing
Exit Function
Else
If mRight > r.Right Then
Inter.Left = r.Left
Inter.Right = r.Right
Else
Inter.Left = r.Left
Inter.Right = mRight
End If
End If
Else

If mLeft > r.Right Then
Inter.Bottom = 0
Inter.Left = 0
Inter.Right = 0
Inter.Top = 0
Set Intersection = Inter
Set Inter = Nothing
Exit Function
Else
If mRight > r.Right Then
Inter.Left = mLeft
Inter.Right = r.Right
Else
Inter.Left = mLeft
Inter.Right = mRight
End If
End If
End If

If mBottom < r.Bottom Then
If mTop < r.Bottom Then

Inter.Bottom = 0
Inter.Left = 0
Inter.Right = 0
Inter.Top = 0
Set Intersection = Inter
Set Inter = Nothing
Exit Function
Else
If mTop > r.Top Then
Inter.Bottom = r.Bottom
Inter.Top = r.Top
Else
Inter.Bottom = r.Bottom
Inter.Top = mTop
End If
End If
Else

If mBottom > r.Top Then
Inter.Bottom = 0
Inter.Left = 0
Inter.Right = 0
Inter.Top = 0
Set Intersection = Inter
Set Inter = Nothing
Exit Function
Else
If mTop > r.Top Then
Inter.Bottom = mBottom
Inter.Top = r.Top
Else
Inter.Bottom = mBottom
Inter.Top = mTop
End If
End If
End If
Set Intersection = Inter
Set Inter = Nothing
End Function

Public Function clone(r As RealRegion)

r.Bottom = mBottom
r.Left = mLeft
r.Right = mRight
r.Top = mTop

End Function

Public Function EstVide() As Boolean
If mBottom = mTop And mRight = mLeft Then
EstVide = True
Else
EstVide = False
End If

End Function

Public Sub ordonne()
Dim X1 As Double


If mBottom > mTop Then
X1 = mTop
mTop = mBottom
mBottom = X1
End If

If mLeft > mRight Then
X1 = mRight
mRight = mLeft
mLeft = X1
End If

End Sub

Public Function Union(r As RealRegion) As RealRegion
Dim un As RealRegion

Set un = New RealRegion


If mBottom = mTop And mLeft = mRight Then

Set Union = r

Set un = Nothing
Exit Function
End If

If r.Left < mLeft Then
un.Left = r.Left
Else
un.Left = mLeft
End If


If r.Right > mRight Then
un.Right = r.Right
Else
un.Right = mRight
End If



If r.Bottom < mBottom Then
un.Bottom = r.Bottom
Else
un.Bottom = mBottom
End If

If r.Top > mTop Then
un.Top = r.Top
Else
un.Top = mTop
End If

Set Union = un

Set un = Nothing
End Function

Public Function Egale(r As RealRegion) As Boolean
If r.Bottom = mBottom And r.Top = mTop And r.Left = mLeft And r.Right =
mRight Then
Egale = True
Else
Egale = False
End If

End Function

Public Function EnvironEgale(r As RealRegion, precision As Integer) As
Boolean
Dim i&

i& = 0

If r.Bottom - mBottom < 10 ^ -precision Then
i& = i& + 1
End If

If r.Top - mTop < 10 ^ -precision Then
i& = i& + 1
End If

If r.Left - mLeft < 10 ^ -precision Then
i& = i& + 1
End If

If r.Right - mRight < 10 ^ -precision Then
i& = i& + 1
End If

If i& >= 3 Then
EnvironEgale = True
Else
EnvironEgale = False
End If

End Function




sergio a écrit :

Bonjour,

je souhaiterais représenter l'agitation moléculaire de particules gazeuses
dans un bocal.
Pour cela, sur un picturebox, je dessine une série de cercles représentant
les molécules. J'ai créé ainsi une collection de particules définies par ses
coordonnées (x,y), sa vitesse et sa direction (par un angle).

Al'aide d'un controle Timer, tous les 100ms, les paramètres de chaque
particule sont recalculés et les particules redessinées sur le picturebox.

De plus, Je dois vérifier que la position d'une particule ne recouvre pas
celle d'une autre particule. Je prends donc en compte les chocs entre
particules une à une.
Vous voyez la procédure est un peu longue en temps car il y a beaucoup de
calculs.

Existerait-il une méthode plus simple pour cela, sans forcément passer par
une collection et être obligé de calculer un à un tous les paramètres afin
que l'animation soit plus fluide également ?

Merci pour votre aide.
Sincères salutations à tous.

Bonjour et merci à Christophe pour ses conseils et son code. Je vais le
tester aujourd'hui.
Par contre, je n'ai jamais essayé GDI. Faut-il un logiciel spécial ? Je
travaille sous VB5.

Salutations sincères.
Serge


"touriste" a écrit :

Bonjour,

Comme Jean-Marc je vous conseil les API graphiques pour la fluidité et
la possibilité de gérer le déplacement des particules de façon
transparente (on ne redessine que les particules pas le bocal). Par
contre je préconise GDI qui est plus ancienne mais qui est robuste et
efficace.

Concernant les calculs d'intersections, un cercle (comme nombre de
figure géomètrique) est inscrit dans un rectangle (et pour ce cas
particulier un carré). Savoir si deux rectangles ont une intersection
non vide est simple et rapide. si l'intersection est vide pas de calcul,
si non calcul de l'intersection réelle, si elle existe calcul du choc et
des nouvelles trajectoires.

Je vous joins la classe RealRegion que j'ai écrite pour gérer les
"rectangles".

A+

Christophe

Option Explicit
Private mLeft As Double
Private mRight As Double
Private mBottom As Double
Private mTop As Double
Private mColor As Long

Public Property Get Color() As Long

Color = mColor

End Property

Public Property Let Color(ByVal Color As Long)

mColor = Color

End Property




Public Property Get Left() As Double

Left = mLeft

End Property

Public Property Let Left(ByVal Left As Double)

mLeft = Left


End Property

Public Property Get Right() As Double


Right = mRight



End Property

Public Property Let Right(ByVal Right As Double)

mRight = Right



End Property

Public Property Get Bottom() As Double

Bottom = mBottom

End Property

Public Property Let Bottom(ByVal Bottom As Double)

mBottom = Bottom


End Property

Public Property Get Top() As Double

Top = mTop

End Property

Public Property Let Top(ByVal Top As Double)

mTop = Top


End Property



Public Function Intersection(r As RealRegion) As RealRegion
Dim Inter As RealRegion
Dim t As Double


Set Inter = New RealRegion



If mLeft < r.Left Then
If mRight < r.Left Then

Inter.Bottom = 0
Inter.Left = 0
Inter.Right = 0
Inter.Top = 0
Set Intersection = Inter
Set Inter = Nothing
Exit Function
Else
If mRight > r.Right Then
Inter.Left = r.Left
Inter.Right = r.Right
Else
Inter.Left = r.Left
Inter.Right = mRight
End If
End If
Else

If mLeft > r.Right Then
Inter.Bottom = 0
Inter.Left = 0
Inter.Right = 0
Inter.Top = 0
Set Intersection = Inter
Set Inter = Nothing
Exit Function
Else
If mRight > r.Right Then
Inter.Left = mLeft
Inter.Right = r.Right
Else
Inter.Left = mLeft
Inter.Right = mRight
End If
End If
End If

If mBottom < r.Bottom Then
If mTop < r.Bottom Then

Inter.Bottom = 0
Inter.Left = 0
Inter.Right = 0
Inter.Top = 0
Set Intersection = Inter
Set Inter = Nothing
Exit Function
Else
If mTop > r.Top Then
Inter.Bottom = r.Bottom
Inter.Top = r.Top
Else
Inter.Bottom = r.Bottom
Inter.Top = mTop
End If
End If
Else

If mBottom > r.Top Then
Inter.Bottom = 0
Inter.Left = 0
Inter.Right = 0
Inter.Top = 0
Set Intersection = Inter
Set Inter = Nothing
Exit Function
Else
If mTop > r.Top Then
Inter.Bottom = mBottom
Inter.Top = r.Top
Else
Inter.Bottom = mBottom
Inter.Top = mTop
End If
End If
End If
Set Intersection = Inter
Set Inter = Nothing
End Function

Public Function clone(r As RealRegion)

r.Bottom = mBottom
r.Left = mLeft
r.Right = mRight
r.Top = mTop

End Function

Public Function EstVide() As Boolean
If mBottom = mTop And mRight = mLeft Then
EstVide = True
Else
EstVide = False
End If

End Function

Public Sub ordonne()
Dim X1 As Double


If mBottom > mTop Then
X1 = mTop
mTop = mBottom
mBottom = X1
End If

If mLeft > mRight Then
X1 = mRight
mRight = mLeft
mLeft = X1
End If

End Sub

Public Function Union(r As RealRegion) As RealRegion
Dim un As RealRegion

Set un = New RealRegion


If mBottom = mTop And mLeft = mRight Then

Set Union = r

Set un = Nothing
Exit Function
End If

If r.Left < mLeft Then
un.Left = r.Left
Else
un.Left = mLeft
End If


If r.Right > mRight Then
un.Right = r.Right
Else
un.Right = mRight
End If



If r.Bottom < mBottom Then
un.Bottom = r.Bottom
Else
un.Bottom = mBottom
End If

If r.Top > mTop Then
un.Top = r.Top
Else
un.Top = mTop
End If

Set Union = un

Set un = Nothing
End Function

Public Function Egale(r As RealRegion) As Boolean
If r.Bottom = mBottom And r.Top = mTop And r.Left = mLeft And r.Right =
mRight Then
Egale = True
Else
Egale = False
End If

End Function

Public Function EnvironEgale(r As RealRegion, precision As Integer) As
Boolean
Dim i&

i& = 0

If r.Bottom - mBottom < 10 ^ -precision Then
i& = i& + 1
End If

If r.Top - mTop < 10 ^ -precision Then
i& = i& + 1
End If

Bonsoir,

j'ai modifié mon code pour m'inspirer du code de M. Renfield.
Malheureusement, le temps mis pour dessiner mes centaines de particules est
beaucoup plus long avec cette méthode, qu'avec ma méthode intiale qui
consistait à dessiner des cercles tout simplement avec l'instruction Circle.
Je suis donc revenu à ma méthode initiale.
Dommage !!

Merci tout de même à tous.

Serge

"sergio" a écrit :

Bonjour,

je souhaiterais représenter l'agitation moléculaire de particules gazeuses
dans un bocal.
Pour cela, sur un picturebox, je dessine une série de cercles représentant
les molécules. J'ai créé ainsi une collection de particules définies par ses
coordonnées (x,y), sa vitesse et sa direction (par un angle).

Al'aide d'un controle Timer, tous les 100ms, les paramètres de chaque
particule sont recalculés et les particules redessinées sur le picturebox.

De plus, Je dois vérifier que la position d'une particule ne recouvre pas
celle d'une autre particule. Je prends donc en compte les chocs entre
particules une à une.
Vous voyez la procédure est un peu longue en temps car il y a beaucoup de
calculs.

Existerait-il une méthode plus simple pour cela, sans forcément passer par
une collection et être obligé de calculer un à un tous les paramètres afin
que l'animation soit plus fluide également ?

Merci pour votre aide.
Sincères salutations à tous.

Bonjour,

effectivement l'utilisation de tableaux dynamiques est plus performant en
vitesse d'exécution qu'une collection.
Merci pour ce tuyau.

Salutations

"Jean-marc" a écrit :

sergio wrote:
> Bonjour,
>
> je souhaiterais représenter l'agitation moléculaire de particules
> gazeuses dans un bocal.
> Pour cela, sur un picturebox, je dessine une série de cercles
> représentant les molécules. J'ai créé ainsi une collection de
> particules définies par ses coordonnées (x,y), sa vitesse et sa
> direction (par un angle).
>
> Al'aide d'un controle Timer, tous les 100ms, les paramètres de chaque
> particule sont recalculés et les particules redessinées sur le
> picturebox.
>
> De plus, Je dois vérifier que la position d'une particule ne recouvre
> pas celle d'une autre particule. Je prends donc en compte les chocs
> entre particules une à une.
> Vous voyez la procédure est un peu longue en temps car il y a
> beaucoup de calculs.
>
> Existerait-il une méthode plus simple pour cela, sans forcément
> passer par une collection et être obligé de calculer un à un tous les
> paramètres afin que l'animation soit plus fluide également ?
>
> Merci pour votre aide.
> Sincères salutations à tous.

Hello,

pour la partie tracé graphique, je te conseille de regarder du coté de
GDI+, le seul moyen de faire des choses vraiment fluides. Un bon
article d'introduction:
http://visualbasic.about.com/od/usingvbnet/a/GDIPlus03.htm

Des choses à voir ici également:
http://www.codeguru.com/vb/gen/vb_graphics/

El alors ici, du code d'excellente facture (salut Renfield!):
http://www.vbfrance.com/codes/EXEMPLE-UTILISATION-GDI-DANS-VB6_39804.aspx

Pour la partie calcul, difficile de dire ce qu'on peut améliorer.
On ignore ce que tu calcules, comment, etc.

Ce que je peux dire, c'est que les collections ne sont pas très efficaces en
terme
de performance pour l'accès aux données, des tableaux dynamiques seraient
plus efficaces.
Maintenant, si l'accès aux données représente peu par rapport à la masse des
calculs, ça n'a sans doute pas d'importance.

Pour les calculs eux-même, mes cours de physique sont loin mais je pense
que si tu peux "ordonner" tes particules, alors tu dois peut être pouvoir
éviter de
calculer certaines interactions, si à partir d'un certain point tu peux
être sur que les points suivants sont trop éloignés et donc n'interagissent
plus
de façon significative avec le suivants. Dans mes souvenirs, les forces en
présence sont en 1/R³, donc ça décroit extrèmement vite.
Ca suppose d'avoir une façon efficace de trier ou d'ordonner d'une
manière ou d'une autre tes particules.
Pour l'aspect tri, même si je doute que se soit adapté directement, voici
tout de même un lien vers l'article de la FAQ sur les tris:
http://faq.vb.free.fr/index.php?question1

<hs>
Je suppose que tes particules sont définies par leurs coordonnées
dans l'espace, donc en 3D. Il y a des méthodes assez efficace
pour déterminer heuristiquement les distances. Notamment en faisant
des projections en plan, on peut se ramener à trier les points sur
un seul axe, ce qui redevient un problème très simple. Ce n'est pas
optimal, ce n'est que heuristique, mais si ca permet déjà d'éliminer
à coup sur disons la motié des particules, comme les calculs d'interactions
entre n particlues exigent plus ou moins [(n)(n-1)]/2 calculs, une
diminution
de n d'un facteur 2 te fait gagner un facteur 4 en terme de nombres de
calculs. Perso, je chercherais dans cette voie.
</hs>

Avec une meilleure description du problème, on pourrait peut être
amener plus de solutions :-)

--
Jean-marc Noury (jean_marc_n2)
Microsoft MVP - Visual Basic
FAQ VB: http://faq.vb.free.fr/
mailto: remove '_no_spam_' ; _no_spam_jean_marc_n2@yahoo.fr

sergio wrote:

Bonjour,

effectivement l'utilisation de tableaux dynamiques est plus
performant en vitesse d'exécution qu'une collection.
Merci pour ce tuyau.

MErci du retour :-)


--
Jean-marc Noury (jean_marc_n2)
Microsoft MVP - Visual Basic
FAQ VB: http://faq.vb.free.fr/
mailto: remove '_no_spam_' ; _no_spam_jean_marc_n2@yahoo.fr

Bonjour,

Jean-marc wrote:

Ce que je peux dire, c'est que les collections ne sont pas très
efficaces en terme de performance pour l'accès aux données,
des tableaux dynamiques seraient plus efficaces.

Effectivement, les collections de VB6 étant organisées comme des listes
doublement chaînées, elles ne sont pas très efficaces en accès
aléatoire. Que l'on accède à un élément par clé ou par index, on
parcourt la liste depuis le début ou la fin à chaque fois. Les
collections .Net sont mieux fichues.

Donc les "tableaux dynamiques" au sens VB6 du terme donneront de
meilleurs résultats. Toutefois, ce n'est pas non plus une réponse
satisfaisante quand on a vraiment besoin d'optimiser, le Redim et le
ReDim Preserve n'étant pas des opérations très efficaces.

La meilleure approche en termes de performances est en fait de mettre en
½uvre des structures de données adaptées au problème (vrais tableaux
dynamiques, piles, files, etc.), écrites en C/C++ en utilisant les
pointeurs comme cela est normalement nécessaire pour de telles
structures et accessibles au code VB6 via un ActiveX Control ou une
ActiveX DLL. C'est ce que propose par exemple ces gens-là:

http://www.sand-stone.com/Datastruct.htm
http://www.entisoft.com/ESToolsF.HTM

Je suis sûr qu'il y en a d'autres et peut-être des gratuits :-) .

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr

Bonjour,

On peut aussi utiliser une contribution bien connue des utilisateurs de
la FAQ VB

http://faq.vb.free.fr/index.php?question4

Et ce les écrire en C.

Une autre solution hybride est l'utilisation d'une base de donnée, ce
qui permet d'utiliser des requêtes pour effectuer des tri complexes.

La problématique des intersections de particules ramenées aux rectangles
comme décrit dans mon post précédent peut-être solutionné par des
requête dites "spatiales". Ce sont ces techniques qui sont utilisées
dans les Systèmes d'Information Géographique, certain type de SGBDR
possède des extentions gérant ce coté "spatial" (Oracle, MySQL,
PostGrès), mais il peut être implanté à la main dans une BD Access.

A+

Christophe


Patrick Philippot a écrit :

Bonjour,

Jean-marc wrote:

Ce que je peux dire, c'est que les collections ne sont pas très
efficaces en terme de performance pour l'accès aux données,
des tableaux dynamiques seraient plus efficaces.

Effectivement, les collections de VB6 étant organisées comme des listes
doublement chaînées, elles ne sont pas très efficaces en accès
aléatoire. Que l'on accède à un élément par clé ou par index, on
parcourt la liste depuis le début ou la fin à chaque fois. Les
collections .Net sont mieux fichues.

Donc les "tableaux dynamiques" au sens VB6 du terme donneront de
meilleurs résultats. Toutefois, ce n'est pas non plus une réponse
satisfaisante quand on a vraiment besoin d'optimiser, le Redim et le
ReDim Preserve n'étant pas des opérations très efficaces.

La meilleure approche en termes de performances est en fait de mettre en
½uvre des structures de données adaptées au problème (vrais tableaux
dynamiques, piles, files, etc.), écrites en C/C++ en utilisant les
pointeurs comme cela est normalement nécessaire pour de telles
structures et accessibles au code VB6 via un ActiveX Control ou une
ActiveX DLL. C'est ce que propose par exemple ces gens-là:

http://www.sand-stone.com/Datastruct.htm
http://www.entisoft.com/ESToolsF.HTM

Je suis sûr qu'il y en a d'autres et peut-être des gratuits :-) .