Table of Contents

## Introduction

In linear algebra, a matrix is a rectangular array of numbers, symbols, or expressions that are arranged in rows and columns. Matrices are commonly used to represent and manipulate data in various fields such as physics, engineering, computer science, and economics.

A column matrix, also known as a column vector, is a matrix that has only one column. It can be thought of as a special case of a matrix where the number of columns is always equal to 1. Column vectors are often used to represent points or vectors in a multidimensional space.

In Python, the numpy library provides a set of functions and classes for working with matrices and arrays. One of the operations that can be performed on matrices is to combine them together to form new matrices. The operation of combining two column matrices, specifically, is to join the two matrices side by side, resulting in a new matrix that has the same number of rows as the original matrices but the number of columns equal to the sum of the columns of the original matrices.

For example, if you have two column matrices, A and B, each with 3 rows and 1 column, you can combine them to form a new matrix C with 3 rows and 2 columns. The elements in the first column of C will be the same as the elements in the first column of A, and the elements in the second column of C will be the same as the elements in the first column of B.

In practice, combining two column matrices is often used to create a more comprehensive representation of a dataset or to perform matrix operations such as linear transformations.

## Different methods to combine matrices in Python using Numpy library

There are several ways to combine matrices in Python using the numpy library:

`np.hstack()`

: This function stacks the matrices horizontally (i.e. side by side) to create a new matrix. The matrices must have the same number of rows in order to be combined using this method.`np.vstack()`

: This function stacks the matrices vertically (i.e. one above the other) to create a new matrix. The matrices must have the same number of columns in order to be combined using this method.`np.concatenate()`

: This function concatenates the matrices along an axis. The axis parameter must be set to 0 for horizontal concatenation and 1 for vertical concatenation. This method also requires that the matrices have the same shape along the specified axis.`np.column_stack()`

: This function is used to combine column vectors into a matrix. It stacks the column vectors vertically and creates a new matrix with the same number of rows as the column vectors and the number of columns equal to the number of column vectors.`np.row_stack()`

: This function is used to combine row vectors into a matrix. It stacks the row vectors horizontally and creates a new matrix with the same number of columns as the row vectors and the number of rows equal to the number of row vectors.

## Method-1: Using `np.hstack()`

function

In this example we create two column matrices (3x1) using the `np.array()`

function and the `np.hstack()`

function is used to stack the two matrices horizontally (i.e. side by side) to create a new matrix.

```
import numpy as np
# create column matrices
mat1 = np.array([[1], [2], [3]])
mat2 = np.array([[4], [5], [6]])
# combine column matrices horizontally
result = np.hstack((mat1, mat2))
print(result)
```

Output

```
[[1 4]
[2 5]
[3 6]]
```

## Method-2: Using `np.concatenate()`

function

In this example, `mat1`

is a 2x2 matrix, and `mat2`

is a 2x3 matrix. The `np.concatenate()`

function is used to concatenate the two matrices along the columns by passing the axis parameter equals to `1`

. The resulting matrix is a `2x5`

matrix.

```
import numpy as np
mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[5, 6, 7], [8, 9, 10]])
result = np.concatenate((mat1, mat2), axis=1)
print(result)
```

Output:

```
[[ 1 2 5 6 7]
[ 3 4 8 9 10]]
```

## Method-3: Using `np.column_stack()`

function

In this code the `np.column_stack()`

function is used to combine column vectors into a matrix. It stacks the column vectors vertically and creates a new matrix with the same number of rows as the column vectors and the number of columns equal to the number of column vectors.

```
import numpy as np
# create column matrices
vec1 = np.array([[1], [2], [3]])
vec2 = np.array([[4], [5], [6]])
result = np.column_stack((vec1, vec2))
print(result)
```

Output:

```
[[1 4]
[2 5]
[3 6]]
```

## Summary

In this tutorial we explored different Numpy library methods to combine matrices in Python. There are several methods available such as `np.hstack()`

, `np.vstack()`

, `np.concatenate()`

, `np.column_stack()`

, `np.row_stack()`

and `np.block()`

. All of these methods allow you to combine matrices together to create new matrices and they don't change the original matrices. You can use the method that best suits your needs and the structure of your data.