Discussion :

[jaky33]

Bonjour,
Je suis en train d'écrire un code me permettant de faire le produit matricielle de k matrices. Le calcul de la matrice M de la fonction multicouche me pose problème. Je souhaite que M soit égale à M1*M2*M3..*Mk avec k le nombre de ligne de ma matrice "couche". Je ne sais pas comment faire ce produit avec np.dot.

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
couche = np.array([[1.8, e],[1.4, e],[1.8, e],[1.4, e]])
s = couche.shape # on regarde la taille de la matrice
nc = s[0] # on prend le nombre de ligne
 
def monocouche(lambda_0,n0,theti,pola,n1,e):
 
 
    thetai2=np.arcsin(n0/n1*np.sin(theti))
 
    h = n1*e*np.cos(thetai2)
 
    if pola == 1 : # pola S
        Y1 = n1*np.cos(thetai2)   
    else : # polar P
        Y1 = np.cos(thetai2)/n1
    phi = k0*h
    M = np.array([[ np.cos(phi) , (np.sin(phi)*1j)/Y1 ], [ (Y1*np.sin(phi))*1j , np.cos(phi) ]])
    return M
 
 
def multicouche(lambda_0,n0,theti,pola,couche):
 
    Id = np.eye(2) # on crée la matrice identité
 
    for k in range(0,nc): # k va varier de 0 à nc-1 
        M = np.dot(Id,monocouche(lambda_0,n0,theti,pola,couche[k,0],couche[k,1])) # M1*M2*M3... k fois
 
    return M

Merci

[lg_53]

Code :

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

1
2
    for k in range(0,nc): # k va varier de 0 à nc-1 
        M = np.dot(Id,monocouche(lambda_0,n0,theti,pola,couche[k,0],couche[k,1])) # M1*M2*M3... k fois

Vous ne faites que calculer chacune de vos couches sans même en garder le résultat (puisque M est écrasé à caque passage dans la boucle for) ...
Qui plus est, si vous écrivez M = Id * monocouche_k, comment pouvez-vous espérer que M soit égale à monocouche_0 * monocouche_1 * ... ?

Code :

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

1
2
3
    M=np.eye(2)
   for k in range(0,nc): # k va varier de 0 à nc-1 
        M = M*monocouche(lambda_0,n0,theti,pola,couche[k,0],couche[k,1]) # M1*M2*M3... k fois

n'est pas mieux ?

PS :
1) A quoi sert lambda_0 ?
2) Ca serait bien de donner un exemple de comment vous souhaitez appeler vos fonctions

[jaky33]

Bonjour,
Je vous remercie pour votre réponse. lambda_0,n0,theti et pola sont des constantes. n1 et e correspondent aux valeurs prises dans la matrice "couche". Avec la fonction np.dot je réalise un produit matricielle mais pas avec "*". Je dois obtenir le même résultat que ceci :

Code :

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

M = np.dot(monocouche(lambda_0,n0,theti,pola,couche[0,0],couche[0,1]),monocouche(lambda_0,n0,theti,pola,couche[1,0],couche[1,1]))

mais pour plusieurs k car je vais rajouter des lignes à ma matrice "couche". Ce que je souhaite faire c'est calculer les matrices M de la fonction monocouche pour les valeurs de n1 et e prise dans la matrice "couche" et ensuite faire le produit matricielle des matrices obtenues (c'est ce que je veux faire avec la fonction multicouche). La fonction monocouche calcule des matrices 2x2 donc quelque soit ma matrice "couche" le résultat de la fonction multicouche doit etre une matrice 2x2. C'est bien ce que j'obtiens mais pas avec les bonnes valeurs. Par exemple si je fais

Code :

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

1
2
3
4
5
M = np.dot(monocouche(lambda_0,n0,theti,pola,couche[0,0],couche[0,1]),monocouche(lambda_0,n0,theti,pola,couche[1,0],couche[1,1]))
#ou
M = np.dot(Id,monocouche(lambda_0,n0,theti,1,couche[k,0],couche[k,1])) 
#ou
M=Id*monocouche(lambda_0,n0,theti,pola,couche[k,0],couche[k,1])

j'obtiens un résultat différent.

[lg_53]

lambda_0 je demande ce que c'est car vous le définissez en tant que paramètre de vos fonctions, mais on ne l'utilise nul part dans les fonctions ...
Ce serait bien de nous donner les valeurs que vous utilisez pour ces paramètres pour qu'on puisse essayer comme vous ...

Pour vos propositions :

Code :

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

1
2
3
4
5
M = np.dot(monocouche(lambda_0,n0,theti,pola,couche[0,0],couche[0,1]),monocouche(lambda_0,n0,theti,pola,couche[1,0],couche[1,1]))
#ou
M = np.dot(Id,monocouche(lambda_0,n0,theti,1,couche[k,0],couche[k,1])) 
#ou
M=Id*monocouche(lambda_0,n0,theti,pola,couche[k,0],couche[k,1])

Il n'y a :
1) aucune chance que ca donne la meme chose.
A moins que monocouche(lambda_0,n0,theti,pola,couche[0,0],couche[0,1]) soit strictement égale à la matrice identité (ce qui me parait peu probable vu qu'il y a des fonctions trigo). Eventuellement ca peu s'en approcher peut etre ...
2) aucune chance n'ont plus que cela fournisse le résultat escompté.
Votre boucle doit avoir un côté récursif. C'est à dire qu'à chaque itération vous devez réutiliser le résultat obtenu à l'itération d'avant.
Dans toutes vos propositions il n'y a aucune récursion



Bon oui effectivement j'ai mis un * au lieu de np.dot. Et donc vous me le faites remarquez et vous n'avez pas eu l'idée de remplacer ce * par une fonction np.dot dans ce que je vous ai proposé ?

Vous avez très clairement des problèmes avec la récursivité. Il suffit de prendre un exemple beaucoup plus simple pour s'en rendre compte. Faisons juste des produits de scalaire (au lieu de considérer des matrices). Je me contente ici de transcrire ce que vous avez écrit avec les matrices :

Code :

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

1
2
3
4
5
6
7
8
9
def produit(a,b):
    return a*b
 
def produit_multiple(list_term):
    nc = len(list_term)
    Id = 1
    for k in range(0,nc): # k va varier de 0 à nc-1 
        M = Id*list_term[k] 
    return M

On voit bien que ca ne va pas du tout. Tester un peu la fonction et vous verrez que ca ne fournit le résultat que de la dernière itération.
Autrement dit ici produit_multiple([3,4,5,6]) va procédé ainsi :
à k=0, M = 1*3 -> 3
à k=1, M = 1*4 -> 4, en oubliant que M a été auparavant égal 3
etc ... en oubliant à chaque fois le résultat de l'étape d'avant
et donc à la fin
k=3, M = 1*6 et le programme vous retourne 6.

Il faut procédé ainsi :

Code :

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

1
2
3
4
    nc = len(list_term)
    M = 1
    for k in range(0,nc): # k va varier de 0 à nc-1 
        M = M*list_term[k] ### Ici vous cumulez. Vous utiliser la précédente valeur de M

Déroulez à la main ce que fait la machine dans cet exemple tout bête et vous verrez l'ampleur de la bêtise de ce que vous avez écrit.