Basic Numerical Linear Algebra/1-Scalars,_Vectors,_Matrices_and_Tensors.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMFsIYh5fmPEcJfwyqudNyo",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MonitSharma/Numerical-Linear-Algebra/blob/main/Scalars%2C_Vectors%2C_Matrices_and_Tensors.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "ldP4Mp1AJ-q3"
      },
      "outputs": [],
      "source": [
        "# import numpy\n",
        "\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Author: [Monit Sharma](https://github.com/MonitSharma),\n",
        "        LinkedIn: [Monit Sharma](https://www.linkedin.com/in/monitsharma/),\n",
        "        Twitter: [@MonitSharma1729](https://twitter.com/MonitSharma1729)"
      ],
      "metadata": {
        "id": "9pfwsve3QvTV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction\n",
        "\n",
        "This first chapter is quite light and concerns the basic elements used in linear algebra and their definitions. It also introduces important functions in Python/Numpy that we will use all along this series. It will explain how to create and use vectors and matrices through examples."
      ],
      "metadata": {
        "id": "ee0f-Du-KJUD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Scalars, Vectors, Matrices and Tensors\n",
        "\n",
        "Let's start with some basic definition\n",
        "\n",
        "![](https://github.com/akhilvasvani/Linear-Algebra-Basics/blob/master/Chapters/2.01%20Scalars%2C%20Vectors%2C%20Matrices%20and%20Tensors/images/scalar-vector-matrix-tensor.png)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "*Difference between a scalar, a vector , a matrix and a tensor*\n",
        "\n",
        "<li> A scalar is a single number or a mtrix with single entry.\n",
        "\n",
        "<li> A vector is a 1-d array of numbers. Another way to think of vectors is identifying points in space with each element giving the coordinate along a different axis.\n",
        "\n",
        "$$ {x} =\\begin{bmatrix}\n",
        "    x_1 \\\\\\\\\n",
        "    x_2 \\\\\\\\\n",
        "    \\cdots \\\\\\\\\n",
        "    x_n\n",
        "\\end{bmatrix}$$\n",
        "\n",
        "\n",
        "<li> A matrix is a 2-D array where each element is identified by two indices (ROW then COLUMN).\n",
        "\n",
        "$$ {A}=\n",
        "\\begin{bmatrix}\n",
        "    A_{1,1} & A_{1,2} & \\cdots & A_{1,n} \\\\\\\\\n",
        "    A_{2,1} & A_{2,2} & \\cdots & A_{2,n} \\\\\\\\\n",
        "    \\cdots & \\cdots & \\cdots & \\cdots \\\\\\\\\n",
        "    A_{m,1} & A_{m,2} & \\cdots & A_{m,n}\n",
        "\\end{bmatrix} $$\n",
        "\n",
        "\n",
        "<li> A tensor is a $n$-dimensional array with $n>2$\n",
        "\n",
        "\n",
        "-------\n",
        "\n",
        "1. scalars are written in lowercase and italics. For instance: $n$\n",
        "\n",
        "2. vectors are written in lowercase, italics and bold type. For instance: $x$\n",
        "\n",
        "3. matrices are written in uppercase, italics and bold. For instance: $X$ \n"
      ],
      "metadata": {
        "id": "R_nYYdKLKS_b"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example 1:\n",
        "\n",
        "### Create a vector with Python and Numpy\n",
        "\n",
        "*Coding tip* : Unlike the `matrix()` function which necessarily creates $2$-dimensional matrices, you can create $n$-dimensional arrays with the `array()` function. The main advantage to use `matrix()` is the useful methods (conjugate transpose, inverse...). We will use the `array()` function in this series.\n",
        "\n",
        "\n",
        "\n",
        "------\n",
        "\n",
        "We will start by creating a vector. This is just a $1$-dimensional array:"
      ],
      "metadata": {
        "id": "jV2PI9z7LUOY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1,2,3,4])\n",
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dSnRFdwsKI1X",
        "outputId": "95497608-ed11-4e53-b96d-204c97d138de"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example 2:\n",
        "\n",
        "### Create a $3 \\times 2$ matrix with nested brackets.\n",
        "\n",
        "The `array()` function can also create $2$ dimensional arrays with nested brackets:"
      ],
      "metadata": {
        "id": "NQocF8OzMQy4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[1,2],[3,4],[5,6]])\n",
        "A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bkr1vJtwMPQG",
        "outputId": "6c9fc8c4-8aa9-4b3e-f5ac-12fd5928b210"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4],\n",
              "       [5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Shape\n",
        "\n",
        "The shape of an array (that is to say its dimensions) tells you the number of values for each dimension. For a \n",
        "$2$-dimensional array it will give you the number of rows and the number of columns. Let's find the shape of our preceding \n",
        "$2$-dimensional array `A`. Since `A` is a Numpy array (it was created with the `array()` function) you can access its shape with:\n"
      ],
      "metadata": {
        "id": "AR3ZBBYeMnnN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5oXR4SydMmVR",
        "outputId": "695b51b5-f4ef-411c-894b-d57b382bf96f"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can see that $A$ has $3$ rows and $2$ columns.\n",
        "\n",
        "-----\n",
        "\n",
        "Let's see the shape of our first vector:"
      ],
      "metadata": {
        "id": "0OglsJDzM2g3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwiEng71M1OD",
        "outputId": "abe6ccea-9d7f-4c2b-fb8a-5df05559ccdf"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4,)"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As expected you can see that $x$ has only one dimension. The number corresponds to the length of the array:"
      ],
      "metadata": {
        "id": "F1zhwj0oNHTn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "len(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XjXRos4mM-7D",
        "outputId": "f8d725a6-02d5-4571-8b54-8f46d19cd9b4"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Transposition\n",
        "\n",
        "With transposition you can convert a row vector to a column vector and vice versa.\n",
        "\n",
        "-----\n",
        "\n",
        "The transpose $A^T$\n",
        " of the matrix $A$\n",
        " corresponds to the mirrored axes. If the matrix is a square matrix (same number of columns and rows).\n",
        "\n",
        "\n",
        " -----\n",
        "\n",
        " $$ {A}=\n",
        "\\begin{bmatrix}\n",
        "    A_{1,1} & A_{1,2} \\\\\\\\\n",
        "    A_{2,1} & A_{2,2} \\\\\\\\\n",
        "    A_{3,1} & A_{3,2}\n",
        "\\end{bmatrix} $$\n",
        "\n",
        "\n",
        "\n",
        "----\n",
        "\n",
        "$${A}^{\\text{T}}=\n",
        "\\begin{bmatrix}\n",
        "    A_{1,1} & A_{2,1} & A_{3,1} \\\\\\\\\n",
        "    A_{1,2} & A_{2,2} & A_{3,2}\n",
        "\\end{bmatrix}$$"
      ],
      "metadata": {
        "id": "eG7xFqO4NW0i"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example 3:\n",
        "\n",
        "### Create a matrix A and transpose it"
      ],
      "metadata": {
        "id": "LXq64I_FN5ze"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[1, 2], [3, 4], [5, 6]])\n",
        "A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "91LrePujNRCv",
        "outputId": "819cd15e-0741-4af1-daa6-6a79d5e7f41d"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4],\n",
              "       [5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A_t = A.T\n",
        "A_t"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v-rILxjAOBXT",
        "outputId": "f1e597b5-952e-49ff-91d5-3b70c91bffc0"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 3, 5],\n",
              "       [2, 4, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Checking the dimensions"
      ],
      "metadata": {
        "id": "5a4Tw6yNOD50"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "To83HyyLODKx",
        "outputId": "c78e42b8-6d1c-49fb-d64a-3b8ead957f8c"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A_t.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wxKVCRuHOGgT",
        "outputId": "2800321c-8be6-44f9-fe93-1d91850fb047"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can see that the number of columns becomes the number of rows with transposition and vice versa."
      ],
      "metadata": {
        "id": "UTvfx2nVOOTZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Addition\n",
        "\n",
        "Matrices can be added if they have the same shape:\n",
        "\n",
        "$$ A + B = C $$\n",
        "\n",
        "Each cell of $A$ is added to the corresponding cell of $B$:\n",
        "\n",
        "$$ {A}_{i,j} + {B}_{i,j} = {C}_{i,j}$$\n",
        "\n",
        "$i$ is the row index and $j$ the column index."
      ],
      "metadata": {
        "id": "Yk8SZlkcOQ3x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "$$ \\begin{bmatrix}\n",
        "    A_{1,1} & A_{1,2} \\\\\\\\\n",
        "    A_{2,1} & A_{2,2} \\\\\\\\\n",
        "    A_{3,1} & A_{3,2}\n",
        "\\end{bmatrix}+\n",
        "\\begin{bmatrix}\n",
        "    B_{1,1} & B_{1,2} \\\\\\\\\n",
        "    B_{2,1} & B_{2,2} \\\\\\\\\n",
        "    B_{3,1} & B_{3,2}\n",
        "\\end{bmatrix}=\n",
        "\\begin{bmatrix}\n",
        "    A_{1,1} + B_{1,1} & A_{1,2} + B_{1,2} \\\\\\\\\n",
        "    A_{2,1} + B_{2,1} & A_{2,2} + B_{2,2} \\\\\\\\\n",
        "    A_{3,1} + B_{3,1} & A_{3,2} + B_{3,2}\n",
        "\\end{bmatrix} $$\n",
        "\n",
        "\n",
        "The shape of $A,B$ and $C$ are identical. Let's check that in an example"
      ],
      "metadata": {
        "id": "N6JRmK-VOp-o"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example 4\n",
        "\n",
        "### Create two matrices A and B and add them\n",
        "\n",
        "With Numpy you can add matrices just as you would add vectors or scalars.\n"
      ],
      "metadata": {
        "id": "ikBG8IxVO0Fq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[1, 2], [3, 4], [5, 6]])\n",
        "A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EnBVLOniOIwt",
        "outputId": "4e1f5e91-8086-4481-ca95-c023e5f3e3c9"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4],\n",
              "       [5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "B = np.array([[2, 5], [7, 4], [4, 3]])\n",
        "B"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kkwADgR8O8s8",
        "outputId": "ff748f7c-2f0c-4df9-97f6-20affaca1cb7"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2, 5],\n",
              "       [7, 4],\n",
              "       [4, 3]])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Add matrices A and B\n",
        "C = A + B\n",
        "C"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xN1aUJWwO-DV",
        "outputId": "b9147777-c03a-4d20-9f34-a95a57e86e47"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 3,  7],\n",
              "       [10,  8],\n",
              "       [ 9,  9]])"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is also possible to add a scalar to a matrix. This means adding this scalar to each cell of the matrix.\n",
        "\n",
        "\n",
        "$$ \\alpha+ \\begin{bmatrix}\n",
        "    A_{1,1} & A_{1,2} \\\\\\\\\n",
        "    A_{2,1} & A_{2,2} \\\\\\\\\n",
        "    A_{3,1} & A_{3,2}\n",
        "\\end{bmatrix}=\n",
        "\\begin{bmatrix}\n",
        "    \\alpha + A_{1,1} & \\alpha + A_{1,2} \\\\\\\\\n",
        "    \\alpha + A_{2,1} & \\alpha + A_{2,2} \\\\\\\\\n",
        "    \\alpha + A_{3,1} & \\alpha + A_{3,2}\n",
        "\\end{bmatrix} $$"
      ],
      "metadata": {
        "id": "AESR1i-QPCC0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example 5\n",
        "\n",
        "### Add a scalar to a matrix"
      ],
      "metadata": {
        "id": "JkuKbVylPGsj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jDG-gHr_O_5x",
        "outputId": "4e232bc6-adc4-4395-cdfe-2e1c3dafbff2"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4],\n",
              "       [5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemple: Add 4 to the matrix A\n",
        "C = A+4\n",
        "C"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nnu816G7PLJV",
        "outputId": "4edf93ac-4fc4-4f77-9934-eb5b9006c0ab"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 5,  6],\n",
              "       [ 7,  8],\n",
              "       [ 9, 10]])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Broadcasting\n",
        "\n",
        "Numpy can handle operations on arrays of different shapes. The smaller array will be extended to match the shape of the bigger one. The advantage is that this is done in C under the hood (like any vectorized operations in Numpy). Actually, we used broadcasting in the example 5. The scalar was converted in an array of same shape as $A$.\n",
        "\n",
        "Here is another generic example:\n",
        "\n",
        "$$ \\begin{bmatrix}\n",
        "    A_{1,1} & A_{1,2} \\\\\\\\\n",
        "    A_{2,1} & A_{2,2} \\\\\\\\\n",
        "    A_{3,1} & A_{3,2}\n",
        "\\end{bmatrix}+\n",
        "\\begin{bmatrix}\n",
        "    B_{1,1} \\\\\\\\\n",
        "    B_{2,1} \\\\\\\\\n",
        "    B_{3,1}\n",
        "\\end{bmatrix} $$\n",
        "\n",
        "is equivalent to\n",
        "\n",
        "$$ \\begin{bmatrix}\n",
        "    A_{1,1} & A_{1,2} \\\\\\\\\n",
        "    A_{2,1} & A_{2,2} \\\\\\\\\n",
        "    A_{3,1} & A_{3,2}\n",
        "\\end{bmatrix}+\n",
        "\\begin{bmatrix}\n",
        "    B_{1,1} & B_{1,1} \\\\\\\\\n",
        "    B_{2,1} & B_{2,1} \\\\\\\\\n",
        "    B_{3,1} & B_{3,1}\n",
        "\\end{bmatrix}=\n",
        "\\begin{bmatrix}\n",
        "    A_{1,1} + B_{1,1} & A_{1,2} + B_{1,1} \\\\\\\\\n",
        "    A_{2,1} + B_{2,1} & A_{2,2} + B_{2,1} \\\\\\\\\n",
        "    A_{3,1} + B_{3,1} & A_{3,2} + B_{3,1}\n",
        "\\end{bmatrix} $$\n",
        "\n",
        "where the ($3\\times 1$\n",
        ") matrix is converted to the right shape ($3\\times 2$\n",
        ") by copying the first column. Numpy will do that automatically if the shapes can match."
      ],
      "metadata": {
        "id": "FkqUbhmsPN39"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example 6\n",
        "\n",
        "### Add two matrices of different shapes"
      ],
      "metadata": {
        "id": "ewtpjAF4Pxqi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[1, 2], [3, 4], [5, 6]])\n",
        "A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G7YejOcnPMvE",
        "outputId": "2578a3b3-0cb3-46b2-b5ff-6c14d97ef527"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4],\n",
              "       [5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "B = np.array([[2], [4], [6]])\n",
        "B"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-uMWNNUdP5m4",
        "outputId": "976f5374-6d89-4613-c888-fdf6895c1972"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2],\n",
              "       [4],\n",
              "       [6]])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Broadcasting\n",
        "C=A+B\n",
        "C"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g0yJonCvP7Sy",
        "outputId": "94e71fad-48ca-4358-eb7d-368bbf1a6208"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 3,  4],\n",
              "       [ 7,  8],\n",
              "       [11, 12]])"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Coding tip*: Sometimes row or column vectors are not in proper shape for broadcasting. We need to imploy a trick ( a `numpy.newaxis` object) to help fix this issue."
      ],
      "metadata": {
        "id": "2ewYtHs7P_YV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.arange(4)\n",
        "x.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y8rEDXELP9oY",
        "outputId": "94feba17-ad56-441b-f0ae-386ea81df7ec"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4,)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Adds a new dimension\n",
        "x[:, np.newaxis]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "riZhBFZYQGio",
        "outputId": "52b087de-6261-4df8-cae7-658bb54c9279"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0],\n",
              "       [1],\n",
              "       [2],\n",
              "       [3]])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.random.randn(4,3)\n",
        "A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6X-7Yy8WQIiY",
        "outputId": "9339c242-841d-4629-d117-b9be66cc286a"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0.37898843,  0.42689999, -1.34790859],\n",
              "       [ 1.59115004,  0.59600385,  0.25510038],\n",
              "       [ 1.08659174, -1.6311077 , -0.78809825],\n",
              "       [ 1.34425773,  0.07104051,  0.06759489]])"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# This will throw an error\n",
        "try:\n",
        "    A - x\n",
        "except ValueError:\n",
        "    print(\"Operation cannot be completed. Dimension mismatch\") "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QivourdbQKbm",
        "outputId": "eea6a3fb-566b-4c44-e259-b625fc0f2387"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Operation cannot be completed. Dimension mismatch\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# But this works -- subtract each column of A by the column vector x\n",
        "A - x[:, np.newaxis]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "75nfP8rfQNHo",
        "outputId": "901af2bb-05b5-4d07-b476-654c07cad8d3"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0.37898843,  0.42689999, -1.34790859],\n",
              "       [ 0.59115004, -0.40399615, -0.74489962],\n",
              "       [-0.91340826, -3.6311077 , -2.78809825],\n",
              "       [-1.65574227, -2.92895949, -2.93240511]])"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "jJE1HX3oQSmj"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}