Get the best out of our app
GFG App
Open App
Browser
Continue

# Kronecker Product of two matrices

Given an m*n matrix A and a p*q matrix B, their Kronecker product C = A tensor B, also called their matrix direct product, is a (m*p) * (n*q) matrix.

```A tensor B =  |a11B   a12B|
|a21B   a22B|

= |a11b11   a11b12   a12b11  a12b12|
|a11b21   a11b22   a12b21  a12b22|
|a11b31   a11b32   a12b31  a12b32|
|a21b11   a21b12   a22b11  a22b12|
|a21b21   a21b22   a22b21  a22b22|
|a21b31   a21b32   a22b31  a22b32|```

Examples:

```1. The matrix direct(kronecker) product of the 2×2 matrix A
and the 2×2 matrix B is given by the 4×4 matrix :

Input : A = 1 2    B = 0 5
3 4        6 7

Output : C = 0  5  0  10
6  7  12 14
0  15 0  20
18 21 24 28

2. The matrix direct(kronecker) product of the 2×3 matrix A
and the 3×2 matrix B is given by the 6×6 matrix :

Input : A = 1 2    B = 0 5 2
3 4        6 7 3
1 0

Output : C = 0      5    2    0     10    4
6      7    3   12     14    6
0     15    6    0     20    8
18     21    9   24     28   12
0      5    2    0      0    0
6      7    3    0      0    0    ```
Recommended Practice

Below is the code to find the Kronecker Product of two matrices and stores it as matrix C :

## C++

 `// C++ code to find the Kronecker Product of two` `// matrices and stores it as matrix C` `#include ` `using` `namespace` `std;`   `// rowa and cola are no of rows and columns` `// of matrix A` `// rowb and colb are no of rows and columns` `// of matrix B` `const` `int` `cola = 2, rowa = 3, colb = 3, rowb = 2;`   `// Function to computes the Kronecker Product` `// of two matrices` `void` `Kroneckerproduct(``int` `A[][cola], ``int` `B[][colb])` `{`   `    ``int` `C[rowa * rowb][cola * colb];`   `    ``// i loops till rowa` `    ``for` `(``int` `i = 0; i < rowa; i++) {`   `        ``// k loops till rowb` `        ``for` `(``int` `k = 0; k < cola; k++) {`   `            ``// j loops till cola` `            ``for` `(``int` `j = 0; j < rowb; j++) {`   `                ``// l loops till colb` `                ``for` `(``int` `l = 0; l < colb; l++) {`   `                    ``// Each element of matrix A is` `                    ``// multiplied by whole Matrix B` `                    ``// resp and stored as Matrix C` `                    ``C[i * rowb + k][j * colb + l]` `                        ``= A[i][j] * B[k][l];` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``for` `(``int` `i = 0; i < rowa * rowb; i++) {` `        ``for` `(``int` `j = 0; j < cola * colb; j++) {` `            ``cout << C[i][j] << ``" "``;` `        ``}` `        ``cout << endl;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A[3][2] = { { 1, 2 }, { 3, 4 }, { 1, 0 } },` `        ``B[2][3] = { { 0, 5, 2 }, { 6, 7, 3 } };`   `    ``Kroneckerproduct(A, B);` `    ``return` `0;` `}`   `// This code is contributed by shubhamsingh10`

## C

 `// C code to find the Kronecker Product of two` `// matrices and stores it as matrix C` `#include `   `// rowa and cola are no of rows and columns` `// of matrix A` `// rowb and colb are no of rows and columns` `// of matrix B` `const` `int` `cola = 2, rowa = 3, colb = 3, rowb = 2;`   `// Function to computes the Kronecker Product` `// of two matrices` `void` `Kroneckerproduct(``int` `A[][cola], ``int` `B[][colb])` `{`   `    ``int` `C[rowa * rowb][cola * colb];`   `    ``// i loops till rowa` `    ``for` `(``int` `i = 0; i < rowa; i++) {`   `        ``// k loops till rowb` `        ``for` `(``int` `k = 0; k < cola; k++) {`   `            ``// j loops till cola` `            ``for` `(``int` `j = 0; j < rowb; j++) {`   `                ``// l loops till colb` `                ``for` `(``int` `l = 0; l < colb; l++) {`   `                    ``// Each element of matrix A is` `                    ``// multiplied by whole Matrix B` `                    ``// resp and stored as Matrix C` `                    ``C[i * rowb + k][j * colb + l]` `                        ``= A[i][j] * B[k][l];` `                ``}` `            ``}` `        ``}` `    ``}` `    ``for` `(``int` `i = 0; i < rowa * rowb; i++) {` `        ``for` `(``int` `j = 0; j < cola * colb; j++) {` `            ``printf``(``"%d "``, C[i][j]);` `        ``}` `        ``printf``(``"\n"``);` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A[3][2] = { { 1, 2 }, { 3, 4 }, { 1, 0 } },` `        ``B[2][3] = { { 0, 5, 2 }, { 6, 7, 3 } };`   `    ``Kroneckerproduct(A, B);` `    ``return` `0;` `}`

## Java

 `// Java code to find the Kronecker Product of` `// two matrices and stores it as matrix C` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// rowa and cola are no of rows and columns` `    ``// of matrix A` `    ``// rowb and colb are no of rows and columns` `    ``// of matrix B` `    ``static` `int` `cola = ``2``, rowa = ``3``, colb = ``3``, rowb = ``2``;`   `    ``// Function to computes the Kronecker Product` `    ``// of two matrices` `    ``static` `void` `Kroneckerproduct(``int` `A[][], ``int` `B[][])` `    ``{`   `        ``int``[][] C = ``new` `int``[rowa * rowb][cola * colb];`   `        ``// i loops till rowa` `        ``for` `(``int` `i = ``0``; i < rowa; i++) {`   `            ``// k loops till rowb` `            ``for` `(``int` `k = ``0``; k < cola; k++) {`   `                ``// j loops till cola` `                ``for` `(``int` `j = ``0``; j < rowb; j++) {`   `                    ``// l loops till colb` `                    ``for` `(``int` `l = ``0``; l < colb; l++) {`   `                        ``// Each element of matrix A is` `                        ``// multiplied by whole Matrix B` `                        ``// resp and stored as Matrix C` `                        ``C[i * rowb + k][j * colb + l]` `                            ``= A[i][j] * B[k][l];` `                    ``}` `                ``}` `            ``}` `        ``}` `        ``for` `(``int` `i = ``0``; i < rowa * rowb; i++) {` `            ``for` `(``int` `j = ``0``; j < cola * colb; j++) {` `                ``System.out.print(C[i][j] + ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `A[][] = { { ``1``, ``2` `}, { ``3``, ``4` `}, { ``1``, ``0` `} };`   `        ``int` `B[][] = { { ``0``, ``5``, ``2` `}, { ``6``, ``7``, ``3` `} };`   `        ``Kroneckerproduct(A, B);` `    ``}` `}`   `// This code is contributed by Gitanjali.`

## Python3

 `# Python code to find the Kronecker Product of two` `# matrices and stores it as matrix C`   `# rowa and cola are no of rows and columns` `# of matrix A` `# rowb and colb are no of rows and columns` `# of matrix B` `cola ``=` `2` `rowa ``=` `3` `colb ``=` `3` `rowb ``=` `2``;`   `# Function to computes the Kronecker Product` `# of two matrices` `def` `Kroneckerproduct(A, B):`   `    ``C ``=` `[[``0``] ``*` `(cola ``*` `colb)  ``for` `_ ``in` `range``(rowa ``*` `rowb) ]` `    `  `    ``# i loops till rowa` `    ``for` `i ``in` `range``(rowa):`   `        ``# k loops till rowb` `        ``for` `k ``in` `range``(cola):`   `            ``# j loops till cola` `            ``for` `j ``in` `range``(rowb):`   `                ``# l loops till colb` `                ``for` `l ``in` `range``(colb):`   `                    ``# Each element of matrix A is` `                    ``# multiplied by whole Matrix B` `                    ``# resp and stored as Matrix C` `                    ``C[i ``*` `rowb ``+` `k][j ``*` `colb ``+` `l]  ``=` `A[i][j] ``*` `B[k][l];` `                `  `    ``for` `i ``in` `range``(rowa ``*` `rowb):` `        ``print``(``*``C[i])` `    `  `# Driver Code` `A ``=` `[[ ``1``, ``2` `], [ ``3``, ``4` `], [ ``1``, ``0` `]];` `B ``=` `[[ ``0``, ``5``, ``2` `], [ ``6``, ``7``, ``3` `]];`   `Kroneckerproduct(A, B);`   `# This code is contributed by phasing17`

## C#

 `// Include namespace system` `using` `System;`   `public` `class` `GFG` `{` `  `  `  ``// rowa and cola are no of rows and columns` `  ``// of matrix A` `  ``// rowb and colb are no of rows and columns` `  ``// of matrix B` `  ``public` `static` `int` `cola = 2;` `  ``public` `static` `int` `rowa = 3;` `  ``public` `static` `int` `colb = 3;` `  ``public` `static` `int` `rowb = 2;` `  ``// Function to computes the Kronecker Product` `  ``// of two matrices` `  ``public` `static` `void` `Kroneckerproduct(``int``[,] A, ``int``[,] B)` `  ``{` `    ``int``[,] C = ``new` `int``[GFG.rowa * GFG.rowb,GFG.cola * GFG.colb];` `    ``// i loops till rowa` `    ``for` `(``int` `i = 0; i < GFG.rowa; i++)` `    ``{` `      ``// k loops till rowb` `      ``for` `(``int` `k = 0; k < GFG.cola; k++)` `      ``{` `        ``// j loops till cola` `        ``for` `(``int` `j = 0; j < GFG.rowb; j++)` `        ``{` `          ``// l loops till colb` `          ``for` `(``int` `l = 0; l < GFG.colb; l++)` `          ``{` `            ``// Each element of matrix A is` `            ``// multiplied by whole Matrix B` `            ``// resp and stored as Matrix C` `            ``C[i * GFG.rowb + k,j * GFG.colb + l] = A[i,j] * B[k,l];` `          ``}` `        ``}` `      ``}` `    ``}` `    ``for` `(``int` `i = 0; i < GFG.rowa * GFG.rowb; i++)` `    ``{` `      ``for` `(``int` `j = 0; j < GFG.cola * GFG.colb; j++)` `      ``{` `        ``Console.Write(C[i,j].ToString() + ``" "``);` `      ``}` `      ``Console.WriteLine();` `    ``}` `  ``}`   `  ``// Driver program` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``int``[,] A = {{1, 2}, {3, 4}, {1, 0}};` `    ``int``[,] B = {{0, 5, 2}, {6, 7, 3}};` `    ``GFG.Kroneckerproduct(A, B);` `  ``}` `}`   `// This code is contributed by aadityaburujwale.`

## Javascript

 `// JS code to find the Kronecker Product of two` `// matrices and stores it as matrix C`     `// rowa and cola are no of rows and columns` `// of matrix A` `// rowb and colb are no of rows and columns` `// of matrix B` `let cola = 2, rowa = 3, colb = 3, rowb = 2;`   `// Function to computes the Kronecker Product` `// of two matrices` `function` `Kroneckerproduct(A, B)` `{`   `    ``let C = ``new` `Array(rowa * rowb)` `    ``for` `(``var` `i = 0; i < rowa * rowb; i++)` `        ``C[i] = ``new` `Array(cola * colb)`   `    ``// i loops till rowa` `    ``for` `(let i = 0; i < rowa; i++) {`   `        ``// k loops till rowb` `        ``for` `(let k = 0; k < cola; k++) {`   `            ``// j loops till cola` `            ``for` `(let j = 0; j < rowb; j++) {`   `                ``// l loops till colb` `                ``for` `(let l = 0; l < colb; l++) {`   `                    ``// Each element of matrix A is` `                    ``// multiplied by whole Matrix B` `                    ``// resp and stored as Matrix C` `                    ``C[i * rowb + k][j * colb + l]` `                        ``= A[i][j] * B[k][l];` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``for` `(let i = 0; i < rowa * rowb; i++) {` `        ``for` `(let j = 0; j < cola * colb; j++) {` `            ``process.stdout.write(C[i][j] + ``" "``);` `        ``}` `        ``console.log()` `    ``}` `}`   `// Driver Code` `let A = [[ 1, 2 ], [ 3, 4 ], [ 1, 0 ]];` `let B = [[ 0, 5, 2 ], [ 6, 7, 3 ]];`   `Kroneckerproduct(A, B);`   `// This code is contributed by phasing17`

Output

```0 5 2 0 10 4
6 7 3 12 14 6
0 15 6 0 20 8
18 21 9 24 28 12
0 5 2 0 0 0
6 7 3 0 0 0 ```

Time Complexity: O(rowa * rowb * cola * colb)
Auxiliary Space: O((rowa * rowb) * (cola * colb))

My Personal Notes arrow_drop_up
Similar Reads
Related Tutorials