Optimiser 4 "if" dansune boucle

Bonjour, voila jaurai voulu savoire si c pas possible d'optimiser ce code pour reduire le nombre de "if" ? je suis sur que sa doit etre possible lol, jai essaye une autre boucle dans la boucle mais sa change rien etant donner quil va faire 4 fois la boucle et donc 4 fois le test "if"...

Bon je suis consciente que je viens pas ici pour me faire servire sur un plateau le nouveau code ! sa minteresserai de voire les possibilitées ou si il ya dautre moyen de pouvoire optimiser ca :


For T = 1 To 50

    Rem Haut ( = 1 )
    If JMove(T) = 1 Then
    Joueur(T).Top = Joueur(T).Top - JMoveSpeed(T)
    If Joueur(T).Top <= JTop(T) Then JMove(T) = 0: Joueur(T).Top = JTop(T)
    End If
   
    Rem Bas ( = 2 )
    If JMove(T) = 2 Then
    Joueur(T).Top = Joueur(T).Top + JMoveSpeed(T)
    If Joueur(T).Top >= JTop(T) Then JMove(T) = 0: Joueur(T).Top = JTop(T)
    End If
    
    Rem Gauche ( = 3 )
    If JMove(T) = 3 Then
    Joueur(T).Left = Joueur(T).Left - JMoveSpeed(T)
    If Joueur(T).Left <= JLeft(T) Then JMove(T) = 0: Joueur(T).Left = JLeft(T)
    End If
    
    Rem Droite ( = 4 )
    If JMove(T) = 4 Then
    Joueur(T).Left = Joueur(T).Left + JMoveSpeed(T)
    If Joueur(T).Left >= JLeft(T) Then JMove(T) = 0: Joueur(T).Left = JLeft(T)
    End If
    
Next T




Merci! kakenette

Salut kakenette

Essaie ceci et dis-moi si cela te convient

For T = 1 To 50
    Select case JMove(T)
          case 1  ' Haut
                 Joueur(T).Top = Joueur(T).Top - JMoveSpeed(T)
                 If Joueur(T).Top <= JTop(T) Then JMove(T) = 0: Joueur(T).Top = JTop(T)
          case 2  ' Bas
                 Joueur(T).Top = Joueur(T).Top + JMoveSpeed(T)
                 If Joueur(T).Top >= JTop(T) Then JMove(T) = 0: Joueur(T).Top = JTop(T)
          case 3  ' Gauche
                 Joueur(T).Left = Joueur(T).Left - JMoveSpeed(T)
                 If Joueur(T).Left <= JLeft(T) Then JMove(T) = 0: Joueur(T).Left = JLeft(T)
          case 4  ' Droite
                 Joueur(T).Left = Joueur(T).Left + JMoveSpeed(T)
                 If Joueur(T).Left >= JLeft(T) Then JMove(T) = 0: Joueur(T).Left = JLeft(T)
    End Select
    
Next T


GRENIER Alain

c se que javais pensée faire mais on ma dit que sa va pas changer le problem car les case il va les faire 1 par 1 comme meme

kakenette

Salut Kakenette

Avec les 4 If le programme va les tester un par un jusqu'à trouver le bon bloc à traiter 
Avec select case le programme va directement au bon bloc à traiter ans les tester un par un

Dans le second cas tu gagnes du temps
GRENIER Alain

Salut Kakenette

Faute de frappe : sans les tester un par un

Avec les 4 If le programme va les tester un par un jusqu'à trouver le bon bloc à traiter 
Avec select case le programme va directement au bon bloc à traiter sans les tester un par un

Dans le second cas tu gagnes du temps


GRENIER Alain

na jai un amis "BurNews" il dit que sa les test un par un car il dit que le compilateur n'est pas devaint enfin voila en attendant jutilise ta solution, celle que je voulais faire.

mais je suis sur que je peut enlever le select case et les if en treiton direcement la valeur de JMove(T)

kakenette

Brunews a raison : dans les 2 cas on les teste un par un et je reconnais m'être trompé
Désolé

GRENIER Alain

Dis donc, toi tu sais choisir tes amis !!! Si BruNews le dit c'est que c'est vrai et on se doit donc de s'incliner.

Cependant, je pense quand même qu'un Select Case reste plus "pratique" dans ce genre de cas.
Mais je ne vois pas ce qu'ici on pourrait réduire si ce n'est le nombre de joueurs!

Enjoy

---

Salut,
ça les teste un par un jusqu'au moment où il trouve
c'est à dire que pour le cas 1 les autres cas sont pas traités, pour le cas 2 on gagne le test 3 et 4, etc...
tout ceci pouvant être remplacé par des ElseIf.

pour utiliser JMove(T) il faudrait l'utiliser en tant qu'opérateur
            Top  et Left
JMove(1) --> -1 et  0
JMove(2) --> +1 et  0
JMove(1) -->  0 et -1 
JMove(2) -->  0 et +1
traiter Left et Top en même temps, mais ça n'empêchera pas les autres tests qui sont différents à chaque fois donc gain de temps ???

NB:
ce qui semble bizarre c'est qu'il n'y a pas de valeurs mini et maxi pour JTop et JLeft
If Joueur(T).Top <= JTopMin(T) Then ...
If Joueur(T).Top >= JTopMax(T) Then ...

Daniel

Salut kakenette,



Le cas des ElseIf est pas mal vu qu'on arrete de tester des qu'on trouve un test à True.

If JMove(T) = 1 Then 
    ' Haut ( = 1 )
ElseIf JMove(T) = 2 Then 
    ' Bas ( = 2 )
ElseIf JMove(T) = 3 Then 
    'Gauche ( = 3 )
Else 
    ' Droite ( = 4 )
End If

Mais pas top, je m'explique avec deux cas extremes :

- si JMove(T) = 1  alors on fait 1 test (nickel)
- si JMove(T) = 4  alors on aura fait 3 tests  (pas top, mais mieux que tes 4)

Tout dépend de la répartition des tes valeurs. Si tu as plus de cas 4 que de cas 1 c'est pas génial.


Tu peux réduire le nombre de test en orientant la recherche de façon dichotomique. En gros, c'est la stratégie visant à diviser pour mieux regner.

Je te propose donc de réduire de moitié les tests effectués à chaque tour.
L'idée c'est de derterminer  :

1) si on est dans le couple (droite,gauche) ou dans le couple (haut,bas)
2) puis afiner pour trouver le bon cas

Const HAUT = 1 
Const BAS = 2 
Const GAUCHE = 3 
Const DROITE = 4 

Sub test() 

  For T = 1 To 50 
    If JMove(T) < GAUCHE Then 
      If JMove(T) = HAUT Then 
        ' Haut
        Joueur(T).Top = Joueur(T).Top - JMoveSpeed(T) 
        If Joueur(T).Top <= JTop(T) Then JMove(T) = 0: _ 
            Joueur(T).Top = JTop(T) 
      Else 
        ' Bas
        Joueur(T).Top = Joueur(T).Top + JMoveSpeed(T) 
        If Joueur(T).Top >= JTop(T) Then JMove(T) = 0: _ 
            Joueur(T).Top = JTop(T) 

      End If 

    Else 
      If JMove(T) = GAUCHE Then 
        'Gauche
        Joueur(T).Left = Joueur(T).Left - JMoveSpeed(T) 
        If Joueur(T).Left <= JLeft(T) Then JMove(T) = 0: _ 
            Joueur(T).Left = JLeft(T) 
      Else 
        ' Droite
        Joueur(T).Left = Joueur(T).Left + JMoveSpeed(T) 
        If Joueur(T).Left >= JLeft(T) Then JMove(T) = 0: _ 
            Joueur(T).Left = JLeft(T) 
      End If 

    End If 
  Next i 

End Sub 

Ainsi à chaque tour de boucle, il ne sera fait que deux tests au lieu des quatre que l'on avait tant avec la méthode des If que celle des Select


On passe donc dans le pire des cas

de 50 * 4  = 200 tests  (If - Select)
à  50 * 3   = 150 tests (ElseIf)
à  50 * 2   = 100 tests

En stockant dans une variable en début de boucle, le contenu de JMove(T) et en utilisant cette variable dans les tests, c'est possibles que tu gagnes un peux de temps.

NB: tu devrais utiliser des constantes pour aider à la lisibilitée de ton code et également à la maintenance. Ecrire en dur dans le code des valeurs, c'est souvent pas une bonne idées.

A toi de selectionner le code qui convient en fonction de la répartition de tes données dans le tableau.

Bon dev,

++

Zlub