Multiplication du tableau nu

Numpy est la bibliothèque de Python qui nous fournit un large éventail de méthodes pour effectuer divers calculs mathématiques sur les tableaux. En ce qui concerne la multiplication d'un tableau, il est facile de multiplier 2 × 2, 3 × 3 ou jusqu'à 5 × 5. Mais quand il dépasse la taille 5 × 5, il peut être difficile de prendre du temps pour les multiplier manuellement. Mais les fonctions intégrées Numpy nous ont facilité la multiplication sur les grands tableaux. La multiplication matricielle est celle dans laquelle deux matrices sont multipliées et donne une seule matrice en conséquence. Il existe trois méthodes fournies par Numpy pour multiplier les matrices.

Il existe trois méthodes pour effectuer la multiplication du tableau. Ce sont les suivants:

Le produit DOT des tableaux

Le produit DOT est également connu sous le nom de produit scalaire. Dans ce type de multiplication, une valeur entière constante est multipliée par la matrice, ou deux tableaux des mêmes dimensions sont multipliés. Dans une matrice scalaire, la taille de la matrice n'a pas d'importance lorsqu'une constante est multipliée car nous multiplions simplement la valeur constante par chaque valeur matricielle.

Syntaxe

La syntaxe suivante est utilisée pour calculer le produit DOT du tableau:

NP.DOT (constant_value, tableau)

Ici, deux arguments sont passés en premier - l'un est le nombre constant et l'autre est le tableau à multiplier. Une autre chose à retenir est que cet ordre des arguments passés n'a pas d'importance. Nous pouvons passer le tableau d'abord et le second peut être les valeurs constantes, la même que dans le cas de la multiplication du tableau.

NP.dot (array_a, array_b)

Ici, deux arguments sont passés: ce sont des tableaux.

Exemple 1

Perdons un exemple pour comprendre profondément le produit scalaire. Dans cet exemple, nous multiplierons un tableau avec la valeur constante. Tout d'abord, importez la bibliothèque Numpy lorsque nous utilisons la fonction intégrée fournie par la bibliothèque Numpy. Ensuite, nous déclarons une variable qui contient la valeur qui doit être multipliée par la variable du tableau «Cons_val» ayant une valeur «2» et un tableau qui contient la matrice 2 × 2 ayant des valeurs de «3», «6», «5 "Et" 2 ".

Après avoir déclaré notre variable et notre tableau constant, nous déclarons une autre variable nommée «Résultat_arr» qui contient le produit DOT du tableau. Nous passons le NP.Fonction point () responsable du calcul du produit DOT avec deux arguments: notre tableau et la valeur constante.

Importer Numpy comme NP
Cons_val = 2
arr = [[3, 6], [5, 2]]
reslting_arr = np.Dot (CONS_VAL, ARR)
Print ("Array original:", arr)
Print ("Le produit scalaire de Array Arr est:", Reslting_arr)

Enfin, en utilisant l'instruction print (), nous imprimons les deux tableaux - le tableau d'origine et le tableau résultant qui est le produit DOT de celui d'origine. La sortie de notre code est affichée dans l'échantillon suivant après son exécution:

Exemple 2

Dans l'exemple précédent, nous avons multiplié la valeur constante avec un tableau utilisant le NP.Fonction DOT (). La multiplication scalaire peut également être effectuée sur deux tableaux. Perdons cet exemple pour comprendre le fonctionnement des produits DOT sur différents tableaux. Tout d'abord, en importation avec succès notre bibliothèque Numpy, nous déclarons deux tableaux de la même taille qui sont: array_a dont les valeurs sont «3» et «6» et array_b ayant des valeurs de «12» et «4». Ensuite, nous déclarons une autre variable à laquelle nous attribuons le NP.Fonction point () qui contient deux arguments qui sont nos tableaux qui doivent être multipliés. Ensuite, affichez les deux tableaux d'origine à l'aide des instructions d'impression.

L'extrait suivant est la sortie du code que nous avons exécuté. Le produit scalaire résultant de nos matrices est «60».

Produit matriciel des tableaux

Le produit matriciel du tableau nous permet de multiplier deux tableaux comme nous le faisons mathématiquement. Dans ce type de multiplication, nous prenons une ligne du premier tableau et une colonne du second. La ligne «R1» du premier tableau est multipliée par la colonne «C1» du deuxième tableau, puis nous les ajoutons pour obtenir le produit. Dans ce type de multiplication, les lignes du premier tableau doivent être égales à la colonne du deuxième tableau.

Syntaxe

NP.Matmul (Array1, Array2)

Le Matmul () est la fonction intégrée fournie par la bibliothèque Numpy pour calculer la multiplication matricielle en les passant simplement les tableaux à multiplier. Dans la syntaxe précédente, Array1 et Array2 sont les tableaux que nous multiplierons.

Exemple 1

Pour comprendre l'utilisation de la fonction matmul () plus brièvement, mettons en œuvre un exemple. Une fois que nous avons réussi à importer notre bibliothèque Numpy, nous déclarons deux tableaux - «Arr_A» et «Arr_B». Le tableau Firt, «Arr_A», contient les valeurs «3», «6», «5» et «2» tandis que «Arr_B» contient «12», «4», «6» et «1». Maintenant, passant à l'étape suivante où nous déclarons une autre variable responsable de la maintenance du résultat de la multiplication des tableaux à la variable nommée «Reslting_arr», nous passons la fonction Matmul () avec les tableaux comme arguments. Enfin, nous imprimons les tableaux d'origine et le produit des tableaux que nous avons calculés à l'aide de la fonction matmul ().

Importer Numpy comme NP
arr_a = np.Array ([[3, 6], [5, 2]])
arr_b = np.Array ([[12, 4], [6, 1]])
reslting_arr = np.Matmul (Arr_A, Arr_B)
Print ("Array d'origine A:", Arr_A)
Print ("Array d'origine B:", Arr_B)
Print ("Le produit matriciel de Array Arr est:", Reslting_arr)

Comment ça fonctionne

Dans ce cas, ARR_A (0,0) est multiplié par l'ARR_B (0,0) et ajouté au produit d'Arr_A (0,1) et ARR_B (1,0) pour obtenir l'élément Reslting_Arr (0,0) de le tableau résultant. La même chose est fait pour les éléments suivants qui correspondent les uns aux autres.

Nous avons calculé avec uccess le produit des deux tableaux comme le montre la figure suivante:

Multiplication par élément

Les deux tableaux doivent avoir les mêmes dimensions que 2 × 2, 3 × 3, et ainsi de suite. La multiplication par élément est effectuée en utilisant la fonction intégrée Numpy qui est NP.multiplier().

Syntaxe

NP.multiplier (array1, array2)

Exemple 1

Pour expliquer le concept de multiplication par élément, nous avons donné l'exemple pour obtenir une meilleure compréhension. Incluons d'abord notre bibliothèque Numpy en tant que NP. Après cela, nous initialisons deux variables qui contiennent le tableau d'origine que nous allons multiplier. Array1 contient les valeurs «5», «1», «6» et «2» tandis que Array2 contient les valeurs «3», «3», «4» et «2». Maintenant, nous créons une autre variable qui contient le tableau de multiplication résultant à laquelle nous passons les deux tableaux comme arguments à notre NP.Multiply () Fonction responsable du calcul du produit d'élément.

Comment ça fonctionne

L'ARR_A (0,0) est multiplié par la matrice ARR_B (0, 0). Tandis que arr_a (0,1) est multiplié par l'ARR_B (0,1), et ainsi de suite. Le résultat est stocké dans le tableau résultant que nous avons déclaré en résultant à laquelle nous avons attribué NP.Multiply () Fonction avec deux paramètres qui sont nos tableaux d'origine.

Importer Numpy comme NP
array1 = np.Array ([[5, 1], [6, 2]])
array2 = np.Array ([[3, 3], [4, 2]])
array_result = np.multiplier (array1, array2)
Print ("Original Array1:", Array1)
Print ("Original Array2:", Array2)
print ("Le produit d'élément du tableau de tableau est:", array_result)

En fin de compte, nous imprimons simplement les baies et le tableau résultant à l'aide de l'instruction print (). Quant à l'exécution, l'extrait suivant affiche la sortie de notre code:

Conclusion

Dans cet article, nous avons discuté de la multiplication de la matrice Numpy en utilisant différentes fonctions Numpy. Nous avons fait de notre mieux pour développer les différentes méthodes pour calculer le produit des matrices. Numpy nous permet d'effectuer divers calculs sur les matrices en utilisant les méthodes intégrées simples. Quand il s'agit d'un grand nombre de multiplication matricielle, il peut être maintenu en utilisant simplement les fonctions expliquées. Nous n'avons pas à les calculer manuellement.