combinaisons linéaires en python / numpy - python, tableaux, numpy, algèbre linéaire

salutations,

Je ne sais pas si c'est une question stupide ou non.

Disons que j'ai 3 tableaux numpy, A1, A2, A3 et 3 flotteurs, c1, c2, c3

et j'aimerais évaluer B = A1 * c1 + A2 * c2 + A3 * c3

va calculer numpy comme par exemple,

 E1 = A1*c1
E2 = A2*c2
E3 = A3*c3
D1 = E1+E2
B = D1+E3

ou est-ce plus intelligent que ça? En c ++, j'avais une manière soignée d'abstraire ce genre d'opération.

J'ai défini une série de fonctions générales de modèle "LC", LC pour une combinaison linéaire comme:

template<class T,class D>
void LC( T & R,
T & L0,D C0,
T & L1,D C1,
T & L2,D C2)
{
R = L0*C0
+L1*C1
+L2*C2;
}

puis spécialisé cela pour différents types,

Ainsi, par exemple, pour un tableau, le code ressemblait

for (int i=0; i<L0.length; i++)
R.array[i] =
L0.array[i]*C0 +
L1.array[i]*C1 +
L2.array[i]*C2;

évitant ainsi d'avoir à créer de nouveaux tableaux intermédiaires.

Cela peut sembler désordonné, mais cela a très bien fonctionné.

Je pourrais faire quelque chose de similaire en python, mais je ne suis pas sûr que ce soit nécessaire.

Merci d'avance pour tout aperçu. -entaille

Réponses:

6 pour la réponse № 1

Tandis que numpy, en théorie, pourrait à tout moment toujours mettre à niveau ses internes pour effectuer de merveilleuses optimisations, à l'heure actuelle, il ne fait pas: B = A1*c1 + A2*c2 + A3*c3 va en effet produire puis éliminer les tableaux temporaires intermédiaires ("dépenser" de la mémoire auxiliaire, bien sûr - rien d'autre).

B = A1 * c1 suivi par B += A2 * c2; B += A3 * c3, encore en ce moment, évitera donc de dépenser une partie de cette mémoire temporaire.

Bien sûr, vous pourrez faire la différenceuniquement si vous "opérez dans un environnement avec une mémoire réelle limitée (où une partie de cette mémoire auxiliaire est juste virtuelle et conduit à des défauts de page) et pour des tableaux suffisamment grands pour" dépenser "toute la mémoire réelle, puis une partie. Dans de telles conditions extrêmes, cependant, un peu de refactoring pouvez vous acheter des performances.

---

2 pour la réponse № 2

Telle est l'idée derrière numexpr (Un évaluateur d'expression de tableau numérique rapide pour Python et NumPy). Vous pouvez essayer ce package avant de compiler vos propres routines.

---