Construction tableau ligne après ligne plutôt que colonne après colonne

Bon, de toute façon, ça n'a pas l'air d'avoir d'incidence sur la vitesse d'exécution.

Pour votre macro, 0,046875 dans les deux cas (retour à la ligne et End If, ou pas).

la precision du chronomètre est quelque dizaines de millisecondes (entre 0.01 et 0.1 sec). Donc on peut seulement regarder vers le premier et, avec des doutes, le 2ième chiffre après le virgule. Votre 0.046875 sec = 0.05 sec, mais comprenez immédiatement et mesurer le temps d'un "endif" en plus, c'est ridicule.

Il y a d'autres outils pour mesurer plus précis, mais assez complexe.

Bonjour BsAlv,

Je viens de me rendre compte que ce qui était gourmand en temps d'exécution, ce n'est pas tant mon ancienne méthode de codage, mais plutôt une boucle que j'avais inséré.

Avec mon ancienne méthode, le temps d'exécution est de 80 secondes pour 15 000 lignes.

Sub Exemple()

'Déclarations
    Dim tableau()
    Dim derniereLigne As Integer
    Dim I As Integer

    t = Timer

    derniereLigne = Sheets("Exercice").Cells(Rows.Count, 1).End(xlUp).Row 'Dernière ligne de la base de données
    ReDim tableau(derniereLigne - 1, 3) 'Redimensionnement

    For I = 0 To derniereLigne - 1
    tableau(I, 0) = Sheets("Exercice").Range("A" & I + 1) 'Enregistrement des valeurs dans le tableau 7, 8, 9 , 8, 7
    Next

    For K = 1 To 200
    For L = 1 To 100

    For I = 1 To derniereLigne - 1
    If tableau(I - 1, 0) > 7 + K And tableau(I - 1, 2) = 2 Then
    tableau(I, 1) = 1
    End If

    If tableau(I, 0) > 8 + L Then
    tableau(I, 2) = 2
    End If
    Next

    Next
    Next

    For I = 0 To derniereLigne - 1
    Sheets("Exercice").Range("S" & I + 1) = tableau(I, 0)
    Next

    For I = 0 To derniereLigne - 1
    Sheets("Exercice").Range("T" & I + 1) = tableau(I, 1)
    Next

    For I = 0 To derniereLigne - 1
    Sheets("Exercice").Range("U" & I + 1) = tableau(I, 2)
    Next

MsgBox Timer - t

End Sub

Avec le codage suivant vos conseils, le temps d'exécution est de 59 secondes pour 15 000 lignes.

Sub NouvelleMéthode()

Dim tableau0
Dim tableau1
Dim derniereLigne As Integer
Dim I As Integer

t = Timer

With Sheets("Exercice")

derniereLigne = .Cells(Rows.Count, 1).End(xlUp).Row

tableau0 = .Range("A1:A" & derniereLigne).Value

tableau1 = tableau0

ReDim Preserve tableau1(1 To UBound(tableau0), 1 To 3)

For K = 1 To 200
For L = 1 To 100

For I = 2 To UBound(tableau1)
If tableau1(I - 1, 1) > 7 + K And tableau1(I - 1, 3) = 2 Then
tableau1(I, 2) = 1
End If
If tableau1(I, 1) > 8 + L Then
tableau1(I, 3) = 2
End If
Next

Next
Next

.Range("S1").Resize(UBound(tableau1, 1), UBound(tableau1, 2)).Value = tableau1

End With

MsgBox Timer - t

End Sub

Le gain de temps n'est plus aussi astronomique qu'auparavant.

Vous auriez une idée pour cette nouvelle boucle ?

bonjour,

j'ai ajouté un dictionaire (pour le moment, ne demande pas d'explication) pour noter à des moments clef, le chronomètre et à la fin de la macro, ces temps seront transféré vers le tableau à cellule AA1.

Chaque boucle 'K' est environ 0.25 sec et remplir chaque colonne S:U est environ 0.9 sec.

Donc, c'est a vous de comprendre ce qui se passe, parce que moi, je ne sais pas ce qu'il se passe dans ces boucles.

s

D'accord, merci.

Je vous ai soumis mon problème pour savoir si quelque chose vous choquait (erreurs de codage, etc.) dans ma façon de programmer comme cela a pu être le cas au départ.

A priori, non.

C'est une structure de boucles que je souhaite utiliser. Donc, j'en conclus que d'une manière ou d'une autre, le temps d'exécution sera important.

Ce n'est donc pas ma façon de coder qui est chronophage, c'est plutôt ce que je demande à la machine.

chaque accès (lire/écrire) vers la feuille est "chronophage", donc à éviter !

Pourquoi écrire chaque cellule de S1 à U15.000, un par un, si vous savez le faire en une fois !

Ajouter ceci a la macro, la ligne qui écrit en une fois la plage N1:P15000 et la ligne suivante pour ajouter le temps au dictionaire. Vos 3 boucles consomment 2.5 à 3 secondes, cette nouvelle ligne 0.08 sec (= multiplication *35). Tout ce qui se passen en mémoire est extremement vite, tout le reste ne l'est pas ... .

Donc ces 3 boucles = 200 * 100 * 15.000 boucles = 49 sec >>>> +6.000.000 boucles par seconde

For I = 0 To derniereLigne - 1
          Sheets("Exercice").Range("U" & I + 1) = tableau(I, 2)
     Next
     dict.Add dict.Count, Array("Fin Boucle colonne U ", Timer - t)
     Application.StatusBar = "Fin U"

     Sheets("Exercice").Range("N1").Resize(UBound(tableau) - LBound(tableau) + 1, UBound(tableau, 2) - LBound(tableau, 2) + 1).Value = tableau
    dict.Add dict.Count, Array("Fin Copy N:P", Timer - t)

     If dict.Count Then lo.ListRows.Add.Range.Range("A1").Resize(dict.Count, 2).Value = Application.Index(dict.items, 0, 0)

même truc en lisant 15.000 lignes, lire en 1 fois = immédiatement (0.0000 sec) versus lire 15.000 cellules un par un = 0.2 s (il y a une différence de dimensions, mais en mesurent le temps, cela n'est pas important)

  For I = 0 To derniereLigne - 1
          tableau(I, 0) = Sheets("Exercice").Range("A" & I + 1)     'Enregistrement des valeurs dans le tableau 7, 8, 9 , 8, 7
     Next
     dict.Add dict.Count, Array("lire en boucle " & k, Timer - t)
     a = Sheets("Exercice").Range("A1:A15000")
     b = a
     ReDim Preserve b(1 To 15000, 1 To 3)
     dict.Add dict.Count, Array("lire en 1 fois " & k, Timer - t)

Je ne suis pas certain de bien vous comprendre, mais ce que je voulais dire c'est que peu importe le codage utilisé, mes 3 boucles demanderont toujours vos 49 secondes. Il n'y a pas de codage plus "propre" qui fasse diminuer sensiblement ce temps d'exécution. Là-dessus je crois qu'on est d'accord.

Ce que je voulais aussi montrer, c'est qu'entre mon vieux codage "malpropre" et un codage "comme il faut", la vitesse d'exécution est seulement multipliée par 1,3. On est loin des 50 fois plus vite que j'avais calculé au début pour une simple boucle.

J'en conclus que ce sont les boucles imbriquées qui sont chronophages.

Pour une simple lecture de feuille et écriture d'une boucle, le gain de temps est énorme entre mon codage "tout pourri" et la bonne façon de faire. Dès que les éléments compris entre la lecture et l'écriture se compliquent un peu, le gain de temps est un peu plus à la marge.

C'est en tout cas ce que je crois avoir compris (après avoir passé mon après-midi dessus, quand même).

je pensais que ce boucle de k et de l (200*100 = 20.000 fois la même chose) était là pour "busy doing nothing", donc mesurer le temps d'execution de quelque chose avec une durée extremement courte mais la répéter X fois.

Après vos dernieres réactions, je ne suis plus sûr de cela, je ne sais plus ce que vous essayez à prouver.

Dans cette macro, vous pouvez éliminir votre lecture et ecriture en boucle par ma proposition et 19.999 des 20.000 boucles de k et l. Le résultat sera quelque chose < 0.5 sec ce qui est <1% de votre temps.

Ma triple boucle, c'est du concret. Cela fait partie de mon projet, je ne fais pas de bruit pour rien.

La routine sur laquelle je travaille (mon code "source") à une vitesse d'exécution de 3 minutes et 20 secondes. Il y a donc de la matière entre le point de lecture et le point d'écriture.

Je me demandais juste (pour moi) si ça valait le coup de modifier tout mon code pour gagner 20 secondes sur le point de lecture et d'écriture.

J'ai déjà fait des tests hier après-midi en modifiant mon code de lecture de la feuille (code "propre") et en désactivant l'écriture. Résultat : 4 minutes 2 secondes.

J'ai pas gagné du temps, j'en ai perdu.

Je ne suis pas dans la théorie, j'ai pas envie de devenir codeur universitaire ; je suis dans le réel et je me sert de l'intelligence artificielle la plus disponible comme d'un outil pour essayer de faire marcher mon truc.

Donc si j'ai bien compris tout les messages de ce sujet, il y a :

• Le point de lecture
• Le traitement de l'information
• Le point d'écriture.

Je pêchais au niveau codage sur le point de lecture et d'écriture. Soit.

Maintenant, dans un programme complexe, ce qui va me bouffer le plus de temps, c'est ce qu'il y a au milieu, le traitement de l'information, et là, pas de solution miracle. C'est ce que tant à confirmer votre dernier message (gain de 0,5 secondes).

Donc, une fois que j'ai compris ça, je peux avancer. Et toujours dans le réel.

ma réponse sera plus courte que 3 minutes et 20 secondes, quel mépris, good luck !

Franchement, je ne vois pas où vous trouvez un quelconque mépris dans mes écrits.

J'ai simplement tenté de résumer tous les échanges de ce sujet.

Pour moi, pour les autres, pour vous ; pour voir si j'avais bien tout compris.

Votre vive réaction me fait penser à une phrase de Lacan : "Le réel, c'est quand on se cogne."

Bonjour Fab7627,

A mes yeux, vous n'avez rien résumé du tout, vous n'avez fait qu'amplifier l'incompréhension de celui qui tombera sur le sujet.

Toujours est-il que ce fil n'a que trop duré depuis qu'il a été indiqué comme résolu, je le clôture !

Je pense que BsAlv vous à apporté bon nombre de solutions, mais que vous ne semblez pas vouloir adopter

Si vous avez encore besoin d'aide, merci de créer un nouveau sujet en rappelant celui-ci éventuellement et avec un titre explicite.

A+