Discussion :

[niepoc]

désolé j'ai rectifié mes erreurs...j'ai fait des mauvaises manip

je travaille sur un tableau au début et ensuite j'en créé un autre pour ma deuxième condition

Code :

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

cond3 = (val_l>=(tab_n[:,1]))&(val_l<(tab_n[:,3]))

je bosse sur deux tableaux, car pour appliquer une condition tel que

Code :

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

ligne = tab_n[cond3]

, il faut que cond 3 comprenne autant d'éléments true ou false qu'il y a de lignes dans le tableau ici tab_n

c'est ce qui optimise le code, c'est de réduire le champ de recherche en appliquant la première condition au tableau initial

au début je traite ma première condition dans mon premier for sur un tableau de 600 000 lignes environs

ensuite avec le code

Code :

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

 tab_n=tab[cond1]

je génère un tableau plus petit qui varie de 1 à quelques centaines de lignes

donc mon deuxième for va plus vite comme ça.....

mais bon on peut faire plus vite sans les for c'est certain..........

[eyquem]

Ce qui m’intrigue, c’est que tu es passé d’une boucle

Code :

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

for i in range(0,len(a)):

soit len(a) indices i

à deux boucles imbriquées

Code :

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

1
2
for val in a :
    for val_l in b :

soit len(a) x len(b) couples testés

[eyquem]

Ah c’est mieux une fois corrigé !



Je crois que ce que j’ai écrit sur mon code qui doit être rapide n’est pas faux.
Peut être pas le PLUS rapide, mais il est nécessairement rapide.
En fait , c’est son principe que tu reprends dans ton nouvel algorithme: éviter de faire travailler le programme sur des lignes dont on peut savoir qu’elles ne sont pas bonnes.
Donc le principe est bon.

Mais je crois que si l’augmentation de vitesse que tu obtiens est à ce point prononcée, c’est dû
- pour une partie à la différence d’algo,
mais surtout - en grande partie à la répartition des valeurs dans tes données.

Elles sont quand même spéciales : quand on regarde les colonnes 2 et 8 on voit qu’il y a beaucoup de valeurs répétées tandis que dans les 1 et 3 c’est tout à fait le contraire

Donc:

1/ pour apprécier dans quelle mesure un algorithme est “meilleur“ qu’un autre, il faudrait tester sur un tableau dont les valeurs seraient aléatoires.
Je ferai ça un jour, mais ce n’est pas ton propos

2/ Conséquence qui te concerne cette fois: comme je te l’avais signalé , il convient d’examiner dans quel sens il est plus judicieux de faire examiner les conditions.

Étant donnée ma remarque ci-dessus, il est évident qu’il vaut mieux faire tester sur 1 et 3 avant 2 et 8.



D’ailleurs j’ai complété mon petit code pour voir ce qui se passe avec ton nouvel algo.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
from numpy import array,arange
from time import clock
 
libase = [[ 201., 352.34 ,1.75, 360., 1.75, 360.,
            2. ,352.34 ,2., -1., -1. ,
            -1. ,-1. ,-1. ,-1., -1. ],
 
          [ 202., 0. ,2.,6.79245, 2., 6.79245,
            2.25 ,0. ,2.25, 0.84899998 ,0.69099998,
            0.84899998 ,0.85100001,0.72899997 ,0.833 ,0.76200002],
 
          [ 203. ,6.79245 ,2. ,13.5849 ,2.,13.5849,
            2.25, 6.79245 ,2.25, 0.84899998, 0.69499999,
            0.85000002 ,0.85399997, 0.736 ,0.83600003 ,0.76899999],
 
          [ 202., 0. ,2.,6.79245, 2., 6.79245,
            2.25 ,0. ,2.25, 0.84899998 ,0.69099998,
            0.84899998 ,0.85100001,0.72899997 ,0.833 ,0.76200002],
 
          [ 203. ,6.79245 ,2. ,13.5849 ,2.,13.5849,
            2.25, 6.79245 ,2.25, 0.84899998, 0.69499999,
            0.85000002 ,0.85399997, 0.736 ,0.83600003 ,0.76899999],
 
          [ 204., 13.5849 ,2., 20.3774 ,2. ,20.3774,
            2.25 ,13.5849, 2.25, 0.85100001 ,0.69800001,
            0.85299999, 0.85900003 ,0.73900002 ,0.84299999 ,0.77399999],
 
          [ 205., 20.3774 ,2. ,27.1698 ,2., 27.1698,
            2.25, 20.3774 ,2.25 ,0.84399998 ,0.69099998,
            0.847 ,0.85900003 ,0.741, 0.85399997 ,0.78100002],
 
          [ 206. ,27.1698, 2., 33.9623 ,2.,33.9623,
            2.25 ,27.1698 ,2.25, 0.84200001 ,0.68699998,
            0.84600002, 0.86199999 ,0.74299997, 0.86000001, 0.78799999],
 
          [ 207., 33.9623 ,2., 40.7547, 2., 40.7547,
            2.25, 33.9623, 2.25, 0.838 ,0.67799997,
            0.83999997, 0.85799998 ,0.73100001 ,0.85699999, 0.78100002],
 
          [ 208., 40.7547, 2. ,47.5472 ,2. ,47.5472,
            2.25,40.7547, 2.25 ,0.83999997, 0.676,
            0.84100002 ,0.85600001, 0.72399998 ,0.85500002 ,0.77700001],
 
          [ 209. ,47.5472, 2., 54.3396 ,2., 54.3396,
            2.25, 47.5472 ,2.25, 0.84600002 ,0.68000001,
            0.84500003 ,0.85100001 ,0.72500002 ,0.83999997 ,0.76899999],
 
          [ 210. ,54.3396, 2., 61.1321,2., 61.1321,
            2.25 ,54.3396, 2.25, 0.84200001 ,0.67799997,
            0.838, 0.84100002, 0.71399999, 0.83499998,0.75700003],
 
          [ 212. ,67.9245, 2. ,74.717, 2. ,74.717,
            2.25 ,67.9245 ,2.25 ,0.85100001, 0.69099998,
            0.84600002, 0.84799999, 0.71899998, 0.83899999, 0.76200002],
 
          [ 213. ,74.717, 2., 81.5094, 2. ,81.5094,
            2.25 ,74.717 ,2.25, 0.86799997 ,0.70999998,
            0.86299998 ,0.86500001, 0.736, 0.85100001 ,0.778 ],
 
          [ 214. ,81.5094, 2., 88.3019 ,2., 88.3019,
            2.25, 81.5094 ,2.25 ,0.86299998 ,0.71100003,
            0.86000001 ,0.86199999, 0.73799998 ,0.84200001 ,0.77100003],
 
          [ 215. ,88.3019, 2. ,95.0943, 2. ,95.0943,
            2.25 ,88.3019 ,2.25 ,0.86699998 ,0.72000003,
            0.86299998 ,0.86400002 ,0.74699998 ,0.82800001 ,0.76099998],
 
          [ 216., 95.0943, 2., 101.887 ,2. ,101.887,
            2.25, 95.0943, 2.25, 0.86500001, 0.72500002,
            0.86199999 ,0.86500001, 0.75 ,0.83499998 ,0.764 ],
 
          [ 217. ,101.887 ,2. ,108.679 ,2., 108.679,
            2.25 ,101.887, 2.25 ,0.86299998 ,0.727, 0.861,
            0.86400002, 0.75300002, 0.84500003 ,0.77100003],
 
          [ 218. ,108.679 ,2., 115.472, 2., 115.472,
            2.25 ,108.679 ,2.25 ,0.86699998, 0.73400003,
            0.86500001 ,0.866, 0.75999999, 0.83700001 ,0.76700002],
 
          [ 219. ,115.472, 2. ,122.264, 2. ,122.264,
            2.25, 115.472, 2.25, 0.85900003, 0.73000002,
            0.85699999 ,0.85900003, 0.75599998, 0.833, 0.76599997]]
 
 
 
lifin  = [[ 211. ,61.1321 ,2. ,67.9245 ,2. ,67.9245,
            2.25 ,61.1321, 2.25, 0.84600002, 0.68400002,
            0.84100002 ,0.84200001 ,0.71600002 ,0.83600003, 0.75999999],
 
          [ 220. ,122.264, 2. ,129.057, 2., 129.057,
            2.25 ,122.264 ,2.25 ,0.85600001, 0.72600001,
            0.85500002, 0.85799998, 0.75599998 ,0.83700001 ,0.77200001]]
 
 
 
 
def eyqu(tab,b,a):
    lin,col = tab.shape
    for ln in tab:
        if b>=ln[1] and  b<ln[3] and a>=ln[2] and  a<ln[8] :
            return ln
 
def niep(tab,b,a):
    cond1 = tab[:,1] <= b
    cond3 = b < tab[:,3]
    cond2 = tab[:,2] <= a
    cond8 = a < tab[:,8]
    cond = cond1 & cond2 & cond3 & cond8
    ln = tab[cond]
    return ln
 
def nouv_1(tab,b,a):
    tab = tab[(tab[:,2] <= a) & (a < tab[:,8])]
    return tab[(tab[:,1] <= b) & (b < tab[:,3])]
 
def nouv_2(tab,b,a):
    tab = tab[(tab[:,1] <= b) & (b < tab[:,3])]
    return tab[(tab[:,2] <= a) & (a < tab[:,8])]
 
print eyqu(array(libase+lifin),63,2.1)
print niep(array(libase+lifin),63,2.1)
print
print nouv_1(array(libase+lifin),63,2.1)
print nouv_2(array(libase+lifin),63,2.1)
print
 
 
for k in (1,5,10,20,50,100,500,1000,10000,20000):
    li = k*libase + lifin
    print '\n===================================================================='
    print 'k =',k,'  len(li) =',len(li)
    tab = array(li)
 
    te = clock()
    eyqu(tab,63,2.1)
    tf = clock()
    dey = tf-te
    print 'temps eyqu =',dey
 
    te = clock()
    niep(tab,63,2.1)
    tf = clock()
    dni = tf-te
    print 'temps niep =',dni
    print 'temps niep / temps eyqu =',dni/dey
 
    print
    te = clock()
    nouv_1(tab,63,2.1)
    tf = clock()
    dnouv_1 = tf-te
    print 'temps nouv_1 =',dnouv_1
 
    te = clock()
    nouv_2(tab,63,2.1)
    tf = clock()
    dnouv_2 = tf-te
    print 'temps nouv_2 =',dnouv_2

Mes résultats ne sont pas précisément relatifs à ton code puisque je n’applique des fonctions que pour un couple fixé de valeurs b et a, tandis que tu itères sur a et b, et que tes temps de 105 minutes et 19 secondes doivent concerner l’ensemble de l’exécution.
Mais je ne comprends pas bien certaines choses:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
Python 2.5.1 (r251:54863, Apr 18 2007, 08:51:08) [MSC v.1310 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
 
    ****************************************************************
    Personal firewall software may warn about the connection IDLE
    makes to its subprocess using this computer's internal loopback
    interface.  This connection is not visible on any external
    interface and no data is sent to or received from the Internet.
    ****************************************************************
 
IDLE 1.2.4      ==== No Subprocess ====
>>> 
[ 211.           61.1321        2.           67.9245        2.           67.9245
    2.25         61.1321        2.25          0.84600002    0.68400002
    0.84100002    0.84200001    0.71600002    0.83600003    0.75999999]
[[ 211.           61.1321        2.           67.9245        2.           67.9245
     2.25         61.1321        2.25          0.84600002    0.68400002
     0.84100002    0.84200001    0.71600002    0.83600003    0.75999999]]
 
[[ 211.           61.1321        2.           67.9245        2.           67.9245
     2.25         61.1321        2.25          0.84600002    0.68400002
     0.84100002    0.84200001    0.71600002    0.83600003    0.75999999]]
[[ 211.           61.1321        2.           67.9245        2.           67.9245
     2.25         61.1321        2.25          0.84600002    0.68400002
     0.84100002    0.84200001    0.71600002    0.83600003    0.75999999]]
 
 
====================================================================
k = 1   len(li) = 22
temps eyqu = 0.000661536591906
temps niep = 0.000482742918393
temps niep / temps eyqu = 0.729729729693
 
temps nouv_1 = 0.000557054039064
temps nouv_2 = 0.000707911201062
 
====================================================================
k = 5   len(li) = 102
temps eyqu = 0.00308027975643
temps niep = 0.000512634985625
temps niep / temps eyqu = 0.16642481403
 
temps nouv_1 = 0.000923301704461
temps nouv_2 = 0.000593092138843
 
====================================================================
k = 10   len(li) = 202
temps eyqu = 0.00582085153269
temps niep = 0.000566552452938
temps niep / temps eyqu = 0.0973315415719
 
temps nouv_1 = 0.00112612077805
temps nouv_2 = 0.00053917467153
 
====================================================================
k = 20   len(li) = 402
temps eyqu = 0.0122716713995
temps niep = 0.000680812784822
temps niep / temps eyqu = 0.0554784073545
 
temps nouv_1 = 0.00192007643432
temps nouv_2 = 0.000576050866812
 
====================================================================
k = 50   len(li) = 1002
temps eyqu = 0.0291171084593
temps niep = 0.000894247732731
temps niep / temps eyqu = 0.0307121063886
 
temps nouv_1 = 0.00419522592961
temps nouv_2 = 0.000737803268294
 
====================================================================
k = 100   len(li) = 2002
temps eyqu = 0.0591329344929
temps niep = 0.00152449543157
temps niep / temps eyqu = 0.0257808181623
 
temps nouv_1 = 0.00904109321164
temps nouv_2 = 0.00104789854572
 
====================================================================
k = 500   len(li) = 10002
temps eyqu = 0.29032432893
temps niep = 0.00565490865461
temps niep / temps eyqu = 0.0194779014058
 
temps nouv_1 = 0.0401296812863
temps nouv_2 = 0.00277968289265
 
====================================================================
k = 1000   len(li) = 20002
temps eyqu = 0.583594842361
temps niep = 0.010120001285
temps niep / temps eyqu = 0.0173407997303
 
temps nouv_1 = 0.0826253057301
temps nouv_2 = 0.00499560698358
 
====================================================================
k = 10000   len(li) = 200002
temps eyqu = 5.99469765012
temps niep = 0.127206390756
temps niep / temps eyqu = 0.0212198176089
 
temps nouv_1 = 1.86306108737
temps nouv_2 = 0.0474512822159
 
====================================================================
k = 20000   len(li) = 400002
temps eyqu = 12.4955275042
temps niep = 0.32647417479
temps niep / temps eyqu = 0.0261272823161
 
temps nouv_1 = 4.3966870091
temps nouv_2 = 0.122646313987
>>>

Dans la fonction nouv_1 , j’ai mis le test des conditions sur les colonnes 2-8 avant celui des 1-3,
c’est à dire l’ordre que tu as mis dans ton message.

- ? Or on voit que le temps de nouv_1 est progressivement de plus en plus supérieur au temps de ton précédent algorithme (représenté par la fonction niep)

Comment peux tu observer une vitesse plus élevée sur l’ensemble de l’exécution?
Est-ce que ton algorithme global est vraiment bien goupillé?





- ? Par contre si on met comme dans nouv_2 le test sur les colonnes 1-3 avant celui sur les colonnes 2-8, le temps d’exécution obtenu pour la fonction (nouv_2) est beaucoup plus petit que celui de nouv_1.

Mais il n’est pas petit par rapport à la fonction niep dans le même rapport 19/105 x 60 que tu dis avoir observé.

Alors ? Interrogation similaire: comment peux tu obtenir une telle diminution drastique de temps ?




Mais une chose est claire: nouv_2 (test des 1-3 d'abord) est beaucoup plus rapide que nouv_1 (test des 2-8 d'abord).
Essaie avec tes deux boucles sur a et b inversées, ce devrait être plus rapide encore.




Une denière remarque:

étant donné la structuration des colonnes 1 et 3 avec des valeurs qui, comme tu l’as pointé, s’étagent de façon croissante, et apparemment strictement croissante, je me demande encore une fois si ton algorithme est vraiment bien conçu:

Cet étagement doit se retrouver dans les lignes qui sortent: celle pour le couple a[i],b[i] doit ètre après la ligne du couple a[i-1],b[i-1] logiquement.....

Dans ce cas, ce ne serait pas la peine de faire repartir l’examen des lignes à partir de la première mais à partir de la précédente trouvée , cela suffirait peut être.