Bonjour,

Je sollicite votre aide afin d'améliorer (en terme de performance) mon script. Ce script me permet la résolution d'un très grand nombre de polynôme de second degré dont les coefficients a,b et c (tq: ax^2+bx+c=0) sont stockés dans 3 DataFrame différents.

pour l'exemple on peut admettre que ces trois dataframe sont:
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
 
a=[1]*9
a=np.array(a).reshape((3,3))
aa=pd.DataFrame(a,columns=["a1","a2","a3"])
'''
Out[21]: 
   a1  a2  a3
0   1   1   1
1   1   1   1
2   1   1   1
'''
b=[2]*9
b=np.array(b).reshape((3,3))
bb=pd.DataFrame(b,columns=["b1","b2","b3"])
 
'''
Out[23]: 
   b1  b2  b3
0   2   2   2
1   2   2   2
2   2   2   2
'''
c=[3]*9
c=np.array(c).reshape((3,3))
cc=pd.DataFrame(c,columns=["c1","c2","c3"])
'''
   c1  c2  c3
0   3   3   3
1   3   3   3
2   3   3   3
'''

J'ai donc réécrit ces coefficients dans un seul dataframe:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
 
a_i=["a%s"%i for i in range(1,4)]
b_i=["b%s"%i for i in range(1,4)]
c_i=["c%s"%i for i in range(1,4)]
ABC=pd.DataFrame([list(zip(aa[a_ii],bb[b_ii],cc[c_ii])) for a_ii,b_ii,c_ii in zip(a_i,b_i,c_i)],columns=["abc1","abc2","abc3"])
'''
out:
        abc1       abc2       abc3
0  (1, 2, 3)  (1, 2, 3)  (1, 2, 3)
1  (1, 2, 3)  (1, 2, 3)  (1, 2, 3)
2  (1, 2, 3)  (1, 2, 3)  (1, 2, 3)
'''


finalement j'obtiens les racines de toutes mes équations avec:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
res=pd.DataFrame(ABC.T.applymap(np.roots))
Ce code pas très bien écrit me permet d'obtenir le résultat souhaité, cependant, mon nombre d’équation à résoudre est > 120000=> shape des dataframes = (15000,8) et le code ci dessous est "assez lent" de l'ordre de la minute :/

Avez vous une idée plus élégante et efficace pour améliorer les performances?

Merci par avance!!!

petite question supplémentaire: est ce que l'utilisation des compréhensions de liste ou dictionnaire est plus "performant" que l'utilisation de boucle?