TRIGONOMETRIE CIRCULAIRE

Il est interprété, il faudrait aussi faire le test avec une version compilée pour avoir un ordre d'idée complet

Optimisez le code pour le rendre plus rapide (pas nécessairement plus court !)
La boucle FOR / NEXT est très gourmande en temps d’exécution, évitez-la si vous pouvez.
L’exemple suivant montre la différence de temps d’une boucle FOR/NEXT exécutée 1000 fois sur un tableau de 11 éléments et d’une affectation directe du même tableau 1000 fois.
Pour moi, le ratio de performance est aux alentours de 2 : 1

Code:: dim result,start_time,end_time,final_time ,time_for,time_affectation

dll_on "kernel32"
Test_For(1000)
Test_Affectatation(1000)

END
rem ============================================================================
SUB get_time()
   result = dll_call0("GetTickCount")
END_SUB
rem ============================================================================
SUB Test_For(n)
   dim_local i,j,tabl(10)
   get_time() : start_time = result
   for i = 1 to n
   for j = 0 to 10 : tabl(j) = j : next j
   next i
   get_time() : end_time = result
   time_for = end_time - start_time
   print "Durée Boucle FOR : " + str$(time_for) + " ms"
END_SUB
rem ============================================================================
SUB Test_Affectatation(n)
   dim_local i,j,tabl(10)
   get_time() : start_time = result
   repeat
   tabl(0) = 0
   tabl(1) = 1
   tabl(2) = 2
   tabl(3) = 3
   tabl(4) = 4
   tabl(5) = 5
   tabl(6) = 6
   tabl(7) = 7
   tabl(8) = 8
   tabl(9) = 9
   tabl(10) = 10
   i = i + 1
   until i = n
   get_time() : end_time = result
   time_affectation = end_time - start_time
   print "Durée Affectation : " + str$(time_affectation) + " ms"
   print "Ratio de performance : " + str$(time_for / time_affectation)
END_SUB
rem ============================================================================

Autre optimisation :

Si vous utilisez dans votre code beaucoup de calculs de SIN(a) et COS(a), vous gagnerez beaucoup en terme de rapidité en calculant dès le début tous les SIN / COS de 0 à 360° dans deux tableaux SINUS(360) et COSINUS(360).
En effet l’accès à un tableau en mémoire est beaucoup plus rapide qu’un calcul trigonométrique.
Désormais, dans vos instructions, vous ferez appel au tableau SINUS(a) ou COSINUS(a) avec a en degré et c’est beaucoup plus rapide que le calcul de SIN et de COS

Code:: rem ============================================================================
dim a,pi,rad
dim sinus(360),cosinus(360) : ' tableaux pour stocker sin et cos
pi = acos(-1) : rad = pi/180
for a = 0 to 360
sinus(a) = sin(a*rad) : cosinus(a) = cos(a*rad)
next a
rem ============================================================================

Excellente idée, Papydall, que de créer ces tableaux de valeurs des fonctions trigonométriques !

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Dans mon exemple page précédente (rotation) je remarque que dans les deux boucles imbriquées, pour chaque pixel je fais intervenir deux fois SIN(ra) et deux fois COS(ra), ce qui est idiot, il suffit de les calculer une fois pour toutes.

J'ai donc remplacé par des constantes calculées une fois pour toutes avant la double boucle, sra et cra, mais le gain de temps n'est pas spectaculaire: 27 secondes au lieu de 31... et j'avoue que j'ai été un peu déçu du résultat... Sad

Et si, comme le suggère Papydall, tu calculais toutes ces valeurs une fois pour toutes, au démarrage, pour les déposer dans un tableau ? Je fais ceci:

Code:: dim t1$, t2$, t3$
dim sinus(10), pi, v, i%

pi = 4 * atn(1)
sinus(10) = sin(10*pi/180)

t1$ = time$
for i%=1 to 100000
v = sin(10*pi/180)
next i%
t2$ = time$
for i%=1 to 100000
v = sinus(10)
next i%
t3$ = time$

print t1$
print t2$
print t3$

end

La première boucle met 9 secondes, chez moi, et la seconde 6 secondes. La différence, c'est le remplacement de la fonction trigonométrique par un élément d'un tableau.

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Je vois bien la suggestion de papydall qui est ingénieuse, mais dans mon exemple à moi c'est le sinus et le cosinus du MÊME angle alpha, qui est l'angle de rotation de l'image, que je répétais dans la double boucle, et que j'ai remplacés par deux constantes sra = SIN(alpha) et cra = COS(alpha).

Et je constate que le fait de remplacer deux fois SIN et deux fois COS par pixel pivoté par deux constantes ne fait pas une différence très significative en temps (~10%), je m'attendais à plus.

C'est le reste du traitement qui est très long, mais c'est vrai que c'est de l'interprété, il faudrait voir avec du vrai compilé.
(la même opération avec nconvert.exe met moins d'1s au lieu de 30s en panoramic).

A peu de chose prêt, j'ai fais le test de Klaus et je passe de 24s à 14s en utilisant le tableau avec le code ci dessous

Code:: dim t1$, t2$, t3$
dim sinus(360), pi, v, i%,j%, rad

pi = 4 * atn(1) : rad = pi/180
for i% = 1 to 360
sinus(i%) = sin(i% * rad)
next i%

t1$ = time$
for j% = 1 to 1000
for i%=1 to 360
v = sin(i% * rad)
next i%
next j%
t2$ = time$
for j% = 1 to 1000
for i%=1 to 360
v = sinus(i%)
next i%
next j%
t3$ = time$

print t1$
print t2$
print t3$

end

C'est ça. Environ un tiers d'économie.

je voulais tester avec 2d_image_copy/2d_image_paste
Mais même avec d'anciens codes ça ne marche plus chez moi correctement
Peut_être un effet de la canicule sur mon esprit fatigué Suspect

Il est évident que panoramic n'a pas été conçu pour être véloce; Il ne faut pas se leurrer, "on ne fera jamais d'un âne un cheval de course!"

Je préfère l’histoire du lièvre et et de la tortue :
avec Panoramic j'ai appris à me hâter lentement
Exemple le pb que j'avais plus haut :un "Wait" judicieusement placé
et le voila résolu

» Trigonométrie circulaire et hyperbolique
» Premier pas en trigonométrie
» track_bar circulaire
» Un menu sympa et original de forme circulaire