Salut, je cherche à faire ce genre de chose en numpy, mais je ne trouve pas comment, malgré avoir essayé plusieurs manières de faire avec numpy.multiply et numpy.product.

J'ai une matrice A, qui contient 2 x 2 elements tri-dimensionnels:

A =array(
 [[[ 0,  1,  2],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [ 9, 10, 11]]])

J'aimerais la multiplier, element par element, dans la troisième dimension, avec un vecteur V à deux composantes. Par exemple, pour V = (2, 3), j'aimerais que ma "multiplication" donne:

Resultat =array(
 [[[ (0, 0),  (2, 3),  (4, 6)],
        [(6, 9),  (8, 12),  (10, 15)]],

       [[ (12, 18),  (14, 21),  (16, 24)],
        [(18, 27), (20, 30), (22, 33)]]])

Quelqu'un peut m'aider ? Evidemment, je pourrais faire ça en pure python, ou encore faire des copies unidimensionnnelles et reconstruire la matrice finale après-coup, mais je cherche la performances, et j'aimerais une manière entière "numpythonique" de faire la chose.

Merci

Evidemment, je pourrais faire ça en pure python, ou encore faire des copies unidimensionnnelles et reconstruire la matrice finale après-coup, mais je cherche la performances, et j'aimerais une manière entière "numpythonique" de faire la chose.

C'est completement pas coherent ton truc. Si tu cherches la performance, pourquoi tu ecris du python?

En passant, ca ressemble a de la multiplication de tenseur ton truc.

Je vois pas ce qu'il y a d'incohérent à vouloir ou DEVOIR utiliser un langage interprété/pas réputé pour être performant, tout en voulant, DANS ce langage, chercher la performance.

Bah j'ai envie de dire pourquoi pas transformer ta matrice de 1-forme en matrice de scalaire en changeant les dimensions et faire ton calcul dessus en manipulant le tableau directement

Ce que je veux dire, c'est que le modele de performance de python c'est : rien a foutre. "Quand on aura identifie la section critique pour les performances, on reecrira cette section en C."

Donc oui, c'est sur que tu dois pouvoir limiter la casse. Mais si tu as un vrai probleme de performance, la seule vraie solution est de tomber d'un niveau d'abstraction et de gagner un gros facteur.

Tu peux créer un nouveau tableau array et c'est dedans que tu vas stocker les résultats :

M=np.ones((dim_x, dim_y))

for i in range(dim_x):
for j in range(dim_y)'
M[i,j]=(k*A[i,j][0] , k*A[i,j][1]) #(ou remplacer '(' et ')' par '[' et ']')
A=M #ou A=M.copy()

06h48 : oui mais là on fait une boucle python de taille dim_x * dim_y, et ça ruine l'avantage d'utiliser numpy pour la perf.

TheArcanum : je vois vaguement ce que tu veux dire, je vais voir sur le net parce que je sais pas du tout comment faire ça.

Godrik : je suis d'accord pour la "philosophie" dont tu parles. Le problème, c'est que dans certains cas, les performances sont si désastreuses que cela devient difficile de simplement tester le programme, et ce à un stade où on est bien loin de l'implémentation en C des parties critiques du code.
P.S oui je sais, tu vas dire que dans ce cas python n'est pas indiqué pour ce problème^^

Lagrangien, en fait, j'allais dire autre chose. Si python est trop lent pour obtenir un prototype, ca dit quelquechose d'assez fort.
Probablement ce n'est meme pas un probleme de langage, mais un probleme d'approche du probleme. Soit l'algo devrait etre ameliore, soit il faudrait deployer beaucoup plus de ressource de calcul. Penses que quand le code va passer en prod (ou sur un vrai exemple) la charge va certainement etre plus elevee.

Par curiosite, tu essayes de faire quoi?