The Numpy library can be used to perform a variety of mathematical/scientific operations such as matrix cross and dot products, finding sine and cosine values, Fourier transform and shape manipulation, etc. The word Numpy is short-hand notation for "Numerical Python".

In this article, you will see how to solve a system of linear equations using Python's Numpy library.

## What is a System of Linear Equations?

Wikipedia defines a system of linear equations as:

In mathematics, a system of linear equations (or linear system) is a collection of two or more linear equations involving the same set of variables.

The ultimate goal of solving a system of linear equations is to find the values of the unknown variables. Here is an example of a system of linear equations with two unknown variables, `x`

and `y`

:

**Equation 1:**

```
4x + 3y = 20
-5x + 9y = 26
```

To solve the above system of linear equations, we need to find the values of the `x`

and `y`

variables. There are multiple ways to solve such a system, such as Elimination of Variables, Cramer's Rule, Row Reduction Technique, and the Matrix Solution. In this article we will cover the matrix solution.

In the matrix solution, the system of linear equations to be solved is represented in the form of matrix `AX = B`

. For instance, we can represent *Equation 1* in the form of a matrix as follows:

```
A = [[ 4 3]
[-5 9]]
X = [[x]
[y]]
B = [[20]
[26]]
```

To find the value of `x`

and `y`

variables in *Equation 1*, we need to find the values in the matrix `X`

. To do so, we can take the dot product of the inverse of matrix `A`

, and the matrix `B`

as shown below:

```
X = inverse(A).B
```

If you are not familiar with how to find the inverse of a matrix, take a look at this link to understand how to manually find the inverse of a matrix. To understand the matrix dot product, check out this article.

## Solving a System of Linear Equations with Numpy

From the previous section, we know that to solve a system of linear equations, we need to perform two operations: matrix inversion and a matrix dot product. The Numpy library from Python supports both the operations. If you have not already installed the Numpy library, you can do with the following `pip`

command:

```
$ pip install numpy
```

Let's now see how to solve a system of linear equations with the Numpy library.

### Using the inv() and dot() Methods

First, we will find inverse of matrix `A`

that we defined in the previous section.

Let's first create the matrix `A`

in Python. To create a matrix, the `array`

method of the Numpy module can be used. A matrix can be considered as a list of lists where each list represents a row.

In the following script we create a list named `m_list`

, which further contains two lists: `[4,3]`

and `[-5,9]`

. These lists are the two rows in the matrix `A`

. To create the matrix `A`

with Numpy, the `m_list`

is passed to the `array`

method as shown below:

```
import numpy as np
m_list = [[4, 3], [-5, 9]]
A = np.array(m_list)
```

To find the inverse of a matrix, the matrix is passed to the `linalg.inv()`

method of the Numpy module:

```
inv_A = np.linalg.inv(A)
print(inv_A)
```

The next step is to find the dot product between the inverse of matrix `A`

, and the matrix `B`

. It is important to mention that matrix dot product is only possible between the matrices **if the inner dimensions of the matrices are equal** i.e. the number of columns of the left matrix must match the number of rows in the right matrix.

To find the dot product with the Numpy library, the `linalg.dot()`

function is used. The following script finds the dot product between the inverse of matrix `A`

and the matrix `B`

, which is the solution of the *Equation 1*.

```
B = np.array([20, 26])
X = np.linalg.inv(A).dot(B)
print(X)
```

**Output:**

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually *learn* it!

```
[2. 4.]
```

Here, `2`

and `4`

are the respective values for the unknowns `x`

and `y`

in *Equation 1*. To verify, if you plug `2`

in place of the unknown `x`

and `4`

in the place of the unknown `y`

in equation `4x + 3y`

, you will see that the result will be 20.

Let's now solve a system of three linear equations, as shown below:

```
4x + 3y + 2z = 25
-2x + 2y + 3z = -10
3x -5y + 2z = -4
```

The above equation can be solved using the Numpy library as follows:

**Equation 2:**

```
A = np.array([[4, 3, 2], [-2, 2, 3], [3, -5, 2]])
B = np.array([25, -10, -4])
X = np.linalg.inv(A).dot(B)
print(X)
```

In the script above the `linalg.inv()`

and the `linalg.dot()`

methods are chained together. The variable `X`

contains the solution for *Equation 2*, and is printed as follows:

```
[ 5. 3. -2.]
```

The value for the unknowns `x`

, `y`

, and `z`

are 5, 3, and -2, respectively. You can plug these values in *Equation 2* and verify their correctness.

### Using the solve() Method

In the previous two examples, we used `linalg.inv()`

and `linalg.dot()`

methods to find the solution of system of equations. However, the Numpy library contains the `linalg.solve()`

method, which can be used to directly find the solution of a system of linear equations:

```
A = np.array([[4, 3, 2], [-2, 2, 3], [3, -5, 2]])
B = np.array([25, -10, -4])
X2 = np.linalg.solve(A,B)
print(X2)
```

**Output:**

```
[ 5. 3. -2.]
```

You can see that the output is same as before.

### A Real-World Example

Let's see how a system of linear equation can be used to solve real-world problems.

Suppose, a fruit-seller sold 20 mangoes and 10 oranges in one day for a total of $350. The next day he sold 17 mangoes and 22 oranges for $500. If the prices of the fruits remained unchanged on both the days, what was the price of one mango and one orange?

This problem can be easily solved with a system of two linear equations.

Let's say the price of one mango is `x`

and the price of one orange is `y`

. The above problem can be converted like this:

```
20x + 10y = 350
17x + 22y = 500
```

The solution for the above system of equations is shown here:

```
A = np.array([[20, 10], [17, 22]])
B = np.array([350, 500])
X = np.linalg.solve(A,B)
print(X)
```

And here is the output:

```
[10. 15.]
```

The output shows that the price of one mango is $10 and the price of one orange is $15.

## Conclusion

The article explains how to solve a system of linear equations using Python's Numpy library. You can either use `linalg.inv()`

and `linalg.dot()`

methods in chain to solve a system of linear equations, or you can simply use the `solve()`

method. The `solve()`

method is the preferred way.