2_Numpy/22_NumPy_ArrayShapes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Note on Array Shapes\n",
    "\n",
    "\n",
    "## Introduction\n",
    "\n",
    "We discussed that NumPy arrays can be multidimensional, e.g. a 2-dimensional array can be though of as having some rows and some columns. The number of rows and columns determines the so-called shape of an array.\n",
    "\n",
    "How Numpy arrays interact with each other depends on the shapes, which must be 'compatible'. There are multiple ways to change the shape of an array, without changing its data, e.g., changing a 2x3 array (matrix) into a single 6-element array (vector).\n",
    "\n",
    "The following is a quick overview about the different reshaping operations. THere is no need to learn them by heart now, but you should at least have heard of them.\n",
    "\n",
    "| **Category**                        | **Operation**                     | **Function/Method**                                  | **Description**                                   |\n",
    "|-------------------------------------|-----------------------------------|-----------------------------------------------------|---------------------------------------------------|\n",
    "| **Reshaping Arrays**        | Transpose                         | `array.T`, `np.transpose(array)`                    | Flips the dimensions of the array. Keeps overall dimensionality (e.g., 2D stays 2D)                |\n",
    "|                               | Flatten                           | `array.flatten()`, `np.ravel(array)`               | Collapses multi-dimensional array to 1D.          |\n",
    "|                               | Reshape                           | `array.reshape(shape)`                              | Reshapes array without changing data. Can change dimensionality depending of shape the array is cast to.             |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To explore array shapes and their implications further, we create two arrays of equal size (3), but different dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_array = np.array([1,2,3])\n",
    "weird_array  = np.array([[10],[20],[30]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following, get the size, shape and dimensions of both arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print the size, shape and dimension of both arrays here.\n",
    "print(\"Simple Array has shape\", simple_array.shape, \"size\", simple_array.size,  \"and dimension\", simple_array.ndim)\n",
    "print(\"Weird Array has shape\", weird_array.shape, \"size\", weird_array.size, \"and dimension\", weird_array.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__(?)__ What would you expect is the addition of both arrays, `simple_array + weird_array`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try to add both arrays. Does that match your expectations?\n",
    "# Retrieve the size and shape of the resultant array.\n",
    "array_sum = simple_array + weird_array\n",
    "print(\"New array has shape\", array_sum.shape, \"dimensionality\", array_sum.ndim, \"and size\", array_sum.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Broadcasting\n",
    "\n",
    "If we were being mathematically precise, the above addition `simple_array + weird_array` should actually fail, as both arrays \"exist\" in different spaces. Specifically, the array `simple_array` resides in $\\mathbb{R}^3$, meaning it is a 3-dimensional vector, while `weird_array` is an element of $\\mathbb{R}^{3 \\times 1}$, i.e., a 3-by-1 matrix.\n",
    "\n",
    "However, NumPy allows this operation by automatically adjusting the shapes of arrays to make them compatible—a process known as **broadcasting**. Broadcasting enables NumPy to work with arrays of different shapes in element-wise operations by \"stretching\" smaller arrays across the dimensions of larger ones without explicitly copying data. This can be fantastic to use if done intentionally, but if it happens accidentally, can be a source of confusion.\n",
    "\n",
    "Here is how broadcasting works in our case.\n",
    "\n",
    "- `simple_array` with shape `(3,)` is treated as a row vector in $\\mathbb{R}^{1 \\times 3}$.\n",
    "- `weird_array` with shape `(3, 1)` can be thought of as a column vector in $\\mathbb{R}^{3 \\times 1}$.\n",
    "\n",
    "When these arrays are added, broadcasting implicitly reshapes `simple_array` to $(1, 3)$, aligning it with `weird_array`'s shape $(3, 1)$. The result is a new array in $\\mathbb{R}^{3 \\times 3}$, where each element is the sum of corresponding elements in the broadcasted arrays.\n",
    "\n",
    "In general, broadcasting works under these rules:\n",
    "\n",
    "1. If arrays differ in their number of dimensions, the smaller array is padded with dimensions of size 1 on its left side.\n",
    "2. Arrays are compatible in a dimension if they have the same size along that dimension, or if one of them has size 1.\n",
    "3. The resulting array shape is the maximum shape across all arrays for each dimension.\n",
    "\n",
    "This ability to broadcast makes operations more efficient, as it avoids unnecessary data replication while enabling element-wise operations on arrays with different shapes.\n",
    "\n",
    "_If however what we wanted to achieve is actually an element-wise addition of both arrays resulting in an array of equal size as both original arrays, we must adjust the shape of one of the arrays to be compatible with the other. We can either expand the dimensionality of the `simple_array` or reduce the dimensionality of the `weird_array`._\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check that the result of our naive addition is indentical to the above explicit broadcasting rules and the implicit reshaping\n",
    "np.all(simple_array.reshape((1,3))+weird_array == simple_array + weird_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expanded_simple_array = np.expand_dims(simple_array, axis =  1)\n",
    "\n",
    "array_sum = expanded_simple_array + weird_array\n",
    "print(array_sum)\n",
    "print(\"New array has shape\", array_sum.shape, \"dimensionality\", array_sum.ndim, \"and size\", array_sum.size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try this now by reducing the dimensionality of `weird_array`!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing the Shape of Arrays\n",
    "\n",
    "Sometimes, we maybe want to switch rows and columns. Those who know linear algebra will recognise this as the transpose. It's simple in numpy.   \n",
    "You can just use the `.T` attribute.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix_to_transpose = np.asarray([[1,2,3],[4,5,6]])\n",
    "print(\"Original Matrix\")\n",
    "print(matrix_to_transpose)\n",
    "print(\"---\")\n",
    "print(\"Transposed Matrix\")\n",
    "print(matrix_to_transpose.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we might want to put all numbers into a single vector. This can be done using the `.flatten()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix_to_flatten = np.asarray([[1,2,3],[4,5,6]])\n",
    "matrix_to_flatten.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try to flatten the transpose of the matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try to use the reshape method of an array\n",
    "matrix = np.asarray([[1,2,3],[4,5,6]])\n",
    "reshaped = matrix.reshape(3,2)\n",
    "\n",
    "print(f\" Original shape: {matrix.shape}, reshaped: {reshaped.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary and Outlook\n",
    "\n",
    "In this notebook, we have seen that arrays with the same number of elements still can have different shapes and dimensionality, which influences how two arrays are combined when joined by an operator. We have discussed the transpose and the flatten methods as a wy to reshape arrays. Another option to force the array to a predefined shape is given by the `.reshape()` method. In the next notebook, we will discuss the notion of mutability again, and how it relates to subsections of NumPy arrays, such as extracting a specific row or column."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}