# Dense matrices implementation in Python

Posted on Mon 04 February 2019 in coding • 8 min read

Machine learning algorithms often use matrices to store data and compute operations such as multiplications or singular value decomposition. The purpose of this article is to see how matrices are implemented in Python: how the data is stored and how much memory it consumes.

Numpy and SciPy are two major libraries which provide repectivelely dense and sparse implementations. Both rely on Numpy ndarrays, so it is important to first look at how ndarrays are implemented. We will then compare this implementation (on the storage aspect only) to implementations in Python without external library. Last, we will see what Numpy dense matrices are compared to ndarrays.

## Internals of a Numpy ndarray

Numpy is a C extension Python library. It therefore provides C API and code which will help us understand how data is stored. For instance, in C, every ndarray is a pointer to a PyArrayObject C structure. This structure is defined as follows:

typedef struct PyArrayObject {
char *data;
int nd;
npy_intp *dimensions;
npy_intp *strides;
PyObject *base;
PyArray_Descr *descr;
int flags;
PyObject *weakreflist;
} PyArrayObject;


The PyArrayObject implementation helps us better understand what the fields are used for:

• PyObject_HEAD is a macro used for Python internal use.
• data is a pointer to the raw data buffer, i.e. the values contained in the array
• nd is the number of dimensions
• dimensions is the size in each dimension, i.e. the shape of the array
• a.strides gives how far in bytes it has to step, for each dimension, to get to the next element of the array (next row, or next column)
• base is a pointer to the original array in the case of a view
• descr is a pointer to the type of the elements stored in the array
• flags gives information about how the array is stored in memory
• weakreflist is a used for weak references

Let's consider an example of an ndarray to explain with more details the fields:

a = np.array([[1, 2, 3],
[4, 5, 6]])


We will first look at the nd and dimensions fields which give general informations about the shape of the ndarray. Then we will see how the elements of the array are stored. References (base and weakreflist fields) are discussed later. Last, the PyObject_HEAD field is presented.

### Shape of the ndarray

The number of dimensions (nd in C) is obtained in Python with:

a.ndim


which outputs 2. The dimensions are the rows and the columns in this case. The size of the array in each dimension (dimensions in C) is obtained in Python with:

a.shape


which outputs (2, 3). It corresponds to the number of rows and the number of columns respectively. These two fields (ndim and shape) can be changed independently of the elements of the array. For instance, if we consider a one dimensional array x and an array y of shape (3, 2) with the same elements:

x = np.array([1, 2, 3, 4, 5, 6])
y = a.reshape(3, 2)


their data is the same:

y.data.tobytes() == a.data.tobytes() == x.data.tobytes()


evaluates to True. Let's get deeper to see how the data is stored.

### How is the data stored?

The data is stored in a.data. Let's set b = a.data.tobytes(). The value a.itemsize gives the number of bytes used to store one element of the array. The value returned by len(b) is 48 which corresponds to the number of bytes a.nbytes and also to the product of a.itemsize (8) and the number of elements (6). The number of bytes used to store one element of the array depends on the type of the elements.

#### Types of the elements

We can see the type used (descr in C) with:

a.dtype


which outputs dtype('int64'). It means that the elements are ints stored with 64 bits each. We can change this type, and then see data as bytes with:

a = a.astype('int16')
b = a.data.tobytes()
print(b)


It outputs b'\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00'. Here, \x01 is the hexadecimal string representation of the bits contained in one byte: for instance 0 is represented by \x00 and 255 is represented by \xff (we can store $$256 = 2^8$$ values in one byte). Since the values are now stored with 16 bits, i.e. 2 bytes, we can retrieve the first two elements of the array (1 and 2) with:

int.from_bytes(b[:2], 'little')
int.from_bytes(b[2:4], 'little')


Two questions arise:

• What does little mean?
• And why is 2 the second element and not 4?

#### Little endian or big endian

Here, little corresponds to little-endian. It means that we read the bytes from left to right to get the number represented. If instead we want the data to be stored in big-endian, we can change it and see the data with:

a = a.astype('>i2')
print(a.data.tobytes())


It now outputs b'\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06'. Note here that each pair of bytes (corresponding to one element of the array) is inverted. We can read the array without changing the data but reading it as if it were stored in little-endian:

a.newbyteorder('<')


which outputs:

array([[ 256,  512,  768],
[1024, 1280, 1536]], dtype=int16)


Let's understand what happened by looking at each element of the array (i.e. two bytes). With big-endian:

bytes in hexadecimal number (big-endian) bits
\x00 \x01 $$2^0 = 1$$ 00000000 00000001
\x00 \x02 $$2^1 = 2$$ 00000000 00000010
\x00 \x03 $$2^0 + 2^1 = 3$$ 00000000 00000011
\x00 \x04 $$2^2 = 4$$ 00000000 00000100
\x00 \x05 $$2^2 + 2^0 = 5$$ 00000000 00000101
\x00 \x06 $$2^2 + 2^1 = 6$$ 00000000 00000110

In this table, we wrote the least significant bit on the right (i.e. if this bit is 1 then it corresponds to $$2^0$$ in the decomposition, the second from the right corresponds to $$2^1$$ and so on). In big-endian, the bytes are read from right to left. If instead we read the same bytes in little-endian (i.e. the least important byte is on the left), we have the following numbers:

bytes in hexadecimal number (little-endian) bits (bytes are reodered)
\x00 \x01 $$2^8 = 256$$ 00000001 00000000
\x00 \x02 $$2^9 = 512$$ 00000010 00000000
\x00 \x03 $$2^8 + 2^9 = 768$$ 00000011 00000000
\x00 \x04 $$2^{10} = 1024$$ 00000100 00000000
\x00 \x05 $$2^8 + 2^{10} = 1280$$ 00000101 00000000
\x00 \x06 $$2^9 + 2^{10} = 1536$$ 00000110 00000000

Note that we inverted the order of the bytes but not all the bits as a whole: for \x00\x01 we get 00000001 00000000 in little-endian and not 10000000 00000000.

We saw how each element is stored individually. Let's see why the second element in the data buffer is 2 (first row and second column) and not 4 (first column and second row).

#### Column major or row major

The second element is 2 because the rows are considered to be laid out as contiguous blocks: 1, 2, 3, 4, 5, 6 (the first row is 1, 2, 3 which are contiguous and the second row is 4, 5, 6). We name it "row major" or "C-style contiguous". The flags property (a.flags) gives us how the data is actually stored in memory:

C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False


In this case the data is stored in C-style. We can also store it as contiguous blocks of columns, called "Fortran-style contiguous" or "column major" with:

y = np.asfortranarray(a)


The flags changed:

C_CONTIGUOUS : False
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False


but the data didn't: a.data == y.data returns True. The data array is still indexed as C-style, even if the underlying data is stored in memory as Fortran-style. This unables to manipulate the array the same way independently of how it is stored in memory. Storing it as row major or column major influences on the efficiency of the operations on the array: for C contiguous memory layout, operations such as a.sum(axis=1) (sums the rows) are usually faster than column-wise operations since they access memory addresses which are next to each other. a.strides gives us how far in bytes it has to step to get to the next value, repectively for the next row and the next column. Here it is (6, 2) for C-style and (2, 4) for Fortran-style.

We saw how each data element is stored and how elements are laid out along with the different fields in the C structure and in Python to get this information. Let's move on to references.

There is one last thing in the C structure we didn't cover yet: PyObject_HEAD. PyObject_HEAD is a macro defined as (see source code of PyObject_HEAD):

PyObject ob_base;


It is used for objects without a varying length as it is the case with an ndarray.

PyObject is defined as (see source code of PyObject):

typedef struct _object {