Working with matrices is always fascinating. The *numpy *library has a ton of functions that helps with carrying out complicated calculations using matrices. In this article, we shall demonstrate one such function that decomposes a given matrix into a pair of entities. This process is called factorization of a matrix & the function of interest would be the *linalg.qr( ) *function.

Before exploring this very function, there is something that needs to be done. The following code shall be deployed to import the *numpy *library.

```
import numpy as np
```

Thereafter, we shall explore further the *linalg.qr( ) *function through each of the following sections.

**The***linalg.qr( )*function – explained**Syntax of the***linalg.qr( )*function**Use cases for the***linalg.qr**( )*function

*Also read: NumPy linalg.matrix_power: Computing the power of a square matrix*

**The ***linalg.qr( )* function – explained

*linalg.qr( )*function – explained

QR factorization is a technique through which a matrix is ripped apart into two different entities. Let’s say, we have a matrix ‘X’, then applying this technique shall result in an orthogonal matrix denoted by ‘Q’ and an upper triangular matrix denoted by ‘R’. To put it in simple terms,

```
X = Q x R
```

Since the results are derivatives of the input matrix, one can observe that the number of elements in each row of the matrix ‘Q’ would be equal to the number of elements in each column of the matrix ‘R’. This seems to be the case due to the rudimentary rule that demands such an arrangement, only through which matrix multiplication is possible.

*Also read: NumPy linalg.det – Compute the determinant of the given array*

**Syntax of the ***linalg.qr( )* function

*linalg.qr( )*function

Given below is the syntax of the *linalg.qr( ) *function with its different components required for its functioning. It is to be noted that the *mode *can be declared with a number of different options such as *reduced, complete, r *or *raw. *The *mode *is set by default to return the results of the *reduced *type.

For an input matrix of dimension MxN, the *reduced mode *results in Q and R matrices of dimensions MxK & KxN respectively. If the *complete mode *is being used for instance, then the Q and R matrices shall be returned with dimensions MxM & MxN respectively.

Declaring an *r mode *shall return only the R matrix with KxN dimension. If one chooses the *raw mode *h & tau are returned with the dimensions NxM & K respectively.

```
numpy.linalg.qr(x, mode)
```

Matrix for which the QR factorization is to be done*x –*Type of factorization that is to be done with the input matrix viz.*mode –**reduced or complete or r or raw*

**Use cases for ***linalg.qr( ) *function

*linalg.qr( )*function

The QR factorization of the input using each mode shall be demonstrated in this section. Let’s construct a matrix of dimension 4×4 and use the default mode (i.e) *reduced *to deduce the Q & R matrices. Following is the code and its corresponding result.

```
m1 = np.array([[-2, 5, 9, 0],
[0, 8, 1, -6],
[3, -5, 2, 7],
[4, 9, 0, -8]])
(q,r) = np.linalg.qr(m1)
print(q)
print(r)
```

Now the *complete *mode shall be used to factorize an input matrix of dimensions 2×3 through the below code.

```
m2 = np.array([[-2, 5, 0],
[0, 1, -6]])
(q,r) = np.linalg.qr(m2, mode = "complete")
print(q)
print(r)
```

It could be observed that the dimension of Q is 2×2, which ain’t a surprise when the number of rows in the input matrix is ‘2’. It is time to use the *r *mode* *for the same input matrix as used above & see what happens.

```
np.linalg.qr(m2, mode = "r")
```

It could be observed that the R matrix in both *complete* & *r* modes is the same. Now let’s try *raw *mode.

```
np.linalg.qr(m2, mode = "raw")
```

Of the results given above, the former is ‘h’ & the latter is ‘tau’.

**Conclusion**

Now that we have reached the end of this article, hope it has elaborated on how to use the *linalg.qr( ) *function from the *numpy *library. Here’s another article that details the usage of the *i0( ) *function from the *numpy *library in Python. There are numerous other enjoyable and equally informative articles in AskPython that might be of great help to those who are looking to level up in Python. *Carpe diem*!