S2_class_notebook_en_teacher.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/lionelalexandre/4TPU271/blob/main/S2_class_notebook_en_teacher.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K9AhWj70lkHh"
      },
      "source": [
        "## <hr style=\"border:1px solid black\"> Teacher / Python class <hr style=\"border:1px solid black\">"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wvhExp9nlkHl"
      },
      "source": [
        "> Python is an object-oriented programming language. Object-oriented programming offer the possibility to create objects which contain both data and functions together. This is referred to as a ***class***. For instance, let's consider the class `vector_2D` which attributes $(x,y)$ coordinates to a vector, ie. $$v\\in\\mathbb{R}^{2}\\quad\\mathrm{with}\\quad\n",
        "\\begin{align}\n",
        "  v &= \\begin{pmatrix}\n",
        "  x \\\\\n",
        "  y \\\\\n",
        "  \\end{pmatrix}\n",
        "\\end{align}$$\n",
        "Consider the python class below"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DJFCp38zlkHm"
      },
      "outputs": [],
      "source": [
        "class vector_2D:\n",
        "    \"\"\" Class to create a  2D vector. \"\"\"\n",
        "    \n",
        "    def __init__(self,x=0.0,y=0.0):\n",
        "        \"\"\" Create a new vector at the origin \"\"\"\n",
        "        self.x = x\n",
        "        self.y = y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rdHa8OX3lkHo"
      },
      "source": [
        "> There header of a class begins with the keyword, `class`, followed by the name of the class, and ending with a colon symbol `:`. \n",
        "\n",
        "> Then comes the initializer function `__init__` which is automatically called when a new object `vector_2D` is created. The `self` variables are automatically set to reference values when the object is initialized.\n",
        "\n",
        "An example of how to create an object from the class `vector_2D` is given below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q_gV_eY_lkHo"
      },
      "outputs": [],
      "source": [
        "vector1 = vector_2D()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b_MpFpLwlkHp"
      },
      "source": [
        "> We said that `vector1` is an object ($\\equiv$ ***instance***) of the class `vector_2D`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zF10VAQ7lkHp",
        "outputId": "62a4338b-c16d-4149-a153-908eb1c7c9c3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<__main__.vector_2D object at 0x7f8fb9c19b20>\n",
            "<class '__main__.vector_2D'>\n"
          ]
        }
      ],
      "source": [
        "print(vector1)\n",
        "print(type(vector1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DhFDZzKFlkHq"
      },
      "source": [
        "> The `x` and `y` are the ***instance attributes*** of `vector1`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DxMX_JYylkHq",
        "outputId": "ee38ac6f-8002-4716-ebd0-0399cd198d3c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.0 0.0\n"
          ]
        }
      ],
      "source": [
        "print(vector1.x,vector1.y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P8beEznjlkHr"
      },
      "source": [
        "> From the initializer function ($\\equiv$  ***initializer method***) we can explicitely attribute `(x,y)` values to the instance vector:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1bniqcK7lkHr",
        "outputId": "64ca229c-7432-4d72-b10a-6008c0b2c4d2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " Class to create a  2D vector. \n",
            "2 1\n"
          ]
        }
      ],
      "source": [
        "vector1 = vector_2D(x=2,y=1)\n",
        "print(vector1.x,vector1.y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K9JMpLcQlkHr"
      },
      "source": [
        "> or implicitely"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VmwadbrClkHs",
        "outputId": "6bd13022-35cd-42da-b79a-1dd078a090e2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 1\n"
          ]
        }
      ],
      "source": [
        "vector1 = vector_2D(2,1)\n",
        "print(vector1.x,vector1.y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4xxMrv5LlkHs"
      },
      "source": [
        "> Plot of the vector"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E6wXDur8lkHs",
        "outputId": "b077c628-5c6a-4dfb-d743-3a231442b102"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 400x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "plt.rcParams[\"figure.figsize\"] = [4.0, 4.0]\n",
        "\n",
        "plt.quiver(0.0, 0.0, vector1.x, vector1.y, color='black', units='xy', scale=1, angles='uv', label='vector1')\n",
        "plt.legend()\n",
        "plt.xlim(-2, 3)\n",
        "plt.ylim(-2, 3)\n",
        "plt.grid()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tZFRP9DTlkHt"
      },
      "source": [
        "We can add a function ($\\equiv$ ***instance method***) to the class, which, for example computes the vector length (distance to the origin) from the instance attributes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-zrvHFZLlkHt"
      },
      "outputs": [],
      "source": [
        "class vector_2D:\n",
        "    \"\"\" Class to create a  2D vector. \"\"\"\n",
        "    \n",
        "    def __init__(self,x=0.0,y=0.0):\n",
        "        \"\"\" Create a new vector at the origin \"\"\"\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "        \n",
        "    def length(self):\n",
        "        \"\"\" Compute length of the vector \"\"\"\n",
        "        return (self.x**2 + self.y**2)**0.5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7wamKkeplkHu"
      },
      "source": [
        "> The method `length` can be called from the instance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BgTgUgwClkHu",
        "outputId": "a5157fb3-7c21-4aca-cde8-720577a6a527"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " Class to create a  2D vector. \n"
          ]
        }
      ],
      "source": [
        "vector1 = vector_2D(2,1)\n",
        "print(vector1.__doc__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qOeG9pXRlkHv"
      },
      "source": [
        "Now the question is to know if we can operate on two objects to obtain a third one. For instance, could we add (or substract) 2 vectors by adding the `x` and `y` coordinates to create a new vector using a class. The response is yes, by using the `__add__()` method. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hs7zi4XTlkHv"
      },
      "outputs": [],
      "source": [
        "class vector_2D:\n",
        "    \"\"\" Class to create a  2D vector. \"\"\"\n",
        "    \n",
        "    def __init__(self,x=0.0,y=0.0):\n",
        "        \"\"\" Create a new vector at the origin \"\"\"\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "        \n",
        "    def length(self):\n",
        "        \"\"\" Compute length of the vector \"\"\"\n",
        "        return (self.x**2 + self.y**2)**0.5      \n",
        "        \n",
        "    def __add__(self, other):\n",
        "        return vector_2D(self.x + other.x, self.y + other.y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jhV-SU-1lkHv"
      },
      "source": [
        "> `__add__()` has 2 arguments `self` for the 1st instance and `other` for the second one  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5Fo4twOjlkHw"
      },
      "outputs": [],
      "source": [
        "vector1 = vector_2D(2, 1)\n",
        "vector2 = vector_2D(1,-1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1Q2hJV2zlkHw",
        "outputId": "d2d85c0e-2894-43a6-fc83-48ac9ac61698"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3 0\n",
            "3.0\n"
          ]
        }
      ],
      "source": [
        "vector3 = vector1 + vector2\n",
        "\n",
        "print(vector3.x, vector3.y)\n",
        "print(vector3.length())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GI6iFhsTlkHw"
      },
      "source": [
        "> Plot of the 3 vectors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FWmpgiP_lkHw",
        "outputId": "c1c17649-60c6-471f-98eb-208daf7d0b6e"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 400x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "plt.rcParams[\"figure.figsize\"] = [4.0, 4.0]\n",
        "\n",
        "plt.quiver(0.0, 0.0, vector1.x, vector1.y, color='black', units='xy', scale=1, angles='uv', label='vector1')\n",
        "plt.quiver(0.0, 0.0, vector2.x, vector2.y, color='blue',  units='xy', scale=1, angles='uv', label='vector2')\n",
        "plt.quiver(0.0, 0.0, vector3.x, vector3.y, color='green', units='xy', scale=1, angles='uv', label='vector3')\n",
        "\n",
        "plt.legend()\n",
        "plt.xlim(-2, 3)\n",
        "plt.ylim(-2, 3)\n",
        "plt.grid()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8GxuRkcGlkHx"
      },
      "source": [
        "> For printing purpose it can be interesting to have a string representation of the vector. Typically, when we want to print the vector components we must explicitely loop over `x`and `y`. When we try to print an instance `vector` we get:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xa_ZeYtwlkHx",
        "outputId": "c17b190f-852d-485c-cb90-8638bf50a15d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<__main__.vector_2D object at 0x7f8f9836faf0>\n"
          ]
        }
      ],
      "source": [
        "print(vector3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o5FnOaUQlkHx"
      },
      "source": [
        "> The solution is bring by the `__str__()` method which can return the instance attributes as a formated\n",
        "string."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fbyd0Wl2lkHx"
      },
      "outputs": [],
      "source": [
        "class vector_2D:\n",
        "    \"\"\" Class to create a  2D vector. \"\"\"\n",
        "    \n",
        "    def __init__(self,x=0.0,y=0.0):\n",
        "        \"\"\" Create a new vector at the origin \"\"\"\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "        \n",
        "    def length(self):\n",
        "        \"\"\" Compute length of the vector \"\"\"\n",
        "        return (self.x**2 + self.y**2)**0.5      \n",
        "        \n",
        "    def __add__(self, other):\n",
        "        return vector_2D(self.x + other.x, self.y + other.y)\n",
        "    \n",
        "    def __str__(self):\n",
        "        return '({0}, {1})'.format(self.x, self.y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CwHuX_2RlkHy"
      },
      "outputs": [],
      "source": [
        "vector1 = vector_2D(2, 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QfOO3AcWlkHy",
        "outputId": "3d2c4caf-fa90-4a87-9b14-88e652f1201c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 1)\n"
          ]
        }
      ],
      "source": [
        "print(vector1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JptN2BbPlkHz"
      },
      "source": [
        "##### Exercise 0.0 <hr style=\"border:1px solid grey\">\n",
        "\n",
        "Build you own complex number class (called `cplx`) *without* using explicit python complex type. Let $z=x+yi$, \n",
        "where $x$ and $y$ are the real and imaginary part, the class should have the following methods:\n",
        "\n",
        "0. Initialization of $(a,b)$ as `self.real` and `self.imag` to zero if no values are provided\n",
        "1. Calculation of the modulus $|z|=\\sqrt{zz^*}$ via `cplx.mod()`\n",
        "1. Print of the complex conjugate via `cplx.conj()`\n",
        "1. Print of the polar coordinates $(r=|z|, \\phi=\\cos^{-1}(a/|z|))$ via `cplx.polar()` [using the function `arccos`of the library numpy.[<sup>1</sup>](#fn1)]\n",
        "\n",
        "<span id=\"fn1\"> $^1$ Note that `arccos` outupt an angle in radian unit. We can convert the value in degree.</span>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YgiZBVCtlkHz"
      },
      "outputs": [],
      "source": [
        "from numpy import arccos, pi"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PcCGJ1jvlkH0"
      },
      "source": [
        "<span style=\"color:red\">**solution :**</span>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uBnn-AA7lkH0"
      },
      "outputs": [],
      "source": [
        "from numpy import arccos, pi\n",
        "\n",
        "class cplx:\n",
        "    \"\"\" Class for a complex number \"\"\"\n",
        "    \n",
        "    def __init__(self,real=0.0,imag=0.0):\n",
        "        \"\"\" Create a new complex number \"\"\"\n",
        "        self.real = real\n",
        "        self.imag = imag\n",
        "        \n",
        "    def mod(self):\n",
        "        \"\"\" Compute and return the module \"\"\"\n",
        "        return (self.real**2 + self.imag**2)**0.5      \n",
        "\n",
        "    def conj(self):\n",
        "        \"\"\" Return cplx conjugate \"\"\"\n",
        "        return (self.real, -self.imag)  \n",
        "\n",
        "    def polar(self):\n",
        "        \"\"\" Return polar coordinates \"\"\"\n",
        "        r  = self.mod()\n",
        "        phi= arccos(self.real/r)*180/pi\n",
        "        return (r, phi) \n",
        "    \n",
        "    def __str__(self):\n",
        "        return '({0}, {1})'.format(self.real, self.imag)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gyPttXq1lkH1",
        "outputId": "a5f1e81d-2725-4317-9432-9d0f22343569"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1.4142135623730951\n",
            "(-1, -1)\n",
            "(1.4142135623730951, 135.0)\n"
          ]
        }
      ],
      "source": [
        "z = cplx(-1,1)\n",
        "\n",
        "print( z.mod()   )\n",
        "print( z.conj()  ) \n",
        "print( z.polar() )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tGkoO8QalkH2"
      },
      "source": [
        "<hr style=\"border:1px solid grey\">"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RRoYlumplkH2"
      },
      "source": [
        "##### Exercise 0.1 <hr style=\"border:1px solid grey\">\n",
        "\n",
        "Having a polar representation of a complex number it becomes easy to perform *exponentiation* since, given $z\\in\\mathbb{C}$ with $z=re^{i\\phi}$:\n",
        "$$z^{n} = \\left(re^{i\\phi}\\right)^n = r^n e^{in\\phi}$$\n",
        "\n",
        "The result can be back transformed using the common relations : $x=r\\cos{\\phi}$ and $y=r\\sin{\\phi}$.\n",
        "> From the equations above, improve the `cplx` class by introducing the *exponentiation* (as `cplx.power(n)`) method. Notice that, this function must has an argument associated to the power $n$.\n",
        "\n",
        "Compare your results to the python build-in function `pow(z,n)` for $z=1+i$, with $n=3$ et $n=1/3$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0ohZY74vlkH2",
        "outputId": "bad4c0b4-2e1a-477a-88e5-d130c2a89c72"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(-2+2j)\n",
            "(1.0842150814913512+0.2905145555072514j)\n"
          ]
        }
      ],
      "source": [
        "z = 1 + 1j\n",
        "\n",
        "print( pow(z,3)   )\n",
        "print( pow(z,1/3) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FmqyMuVglkH2"
      },
      "source": [
        "<span style=\"color:red\">**solution :**</span>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fRcuaMFwlkH3"
      },
      "outputs": [],
      "source": [
        "from numpy import arccos, pi, cos, sin\n",
        "\n",
        "class cplx:\n",
        "    \"\"\" Class for a complex number \"\"\"\n",
        "    \n",
        "    def __init__(self,real=0.0,imag=0.0):\n",
        "        \"\"\" Create a new complex number \"\"\"\n",
        "        self.real = real\n",
        "        self.imag = imag\n",
        "        \n",
        "    def mod(self):\n",
        "        \"\"\" Compute and return the module \"\"\"\n",
        "        return (self.real**2 + self.imag**2)**0.5      \n",
        "\n",
        "    def conj(self):\n",
        "        \"\"\" Return cplx conjugate \"\"\"\n",
        "        return (self.real, -self.imag)  \n",
        "\n",
        "    def polar(self):\n",
        "        \"\"\" Return polar coordinates \"\"\"\n",
        "        r  = self.mod()\n",
        "        phi= arccos(self.real/r)*180/pi\n",
        "        return (r, phi) \n",
        "\n",
        "    def power(self,n):\n",
        "        \"\"\" Return power n of cplx \"\"\"\n",
        "        r, phi = self.polar()\n",
        "        x = r**n * cos(n*phi*pi/180)\n",
        "        y = r**n * sin(n*phi*pi/180)        \n",
        "        return (x, y) \n",
        "    \n",
        "    def __str__(self):\n",
        "        return '({0}, {1})'.format(self.real, self.imag)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KBoDrCTXlkH3"
      },
      "outputs": [],
      "source": [
        "z = cplx(1,1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "b3iTT-VGlkH4",
        "outputId": "42db4ac8-727e-47ac-e0f7-ca241d041199"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(-2.0000000000000013, 1.9999999999999996)\n",
            "(1.0842150814913512, 0.29051455550725147)\n"
          ]
        }
      ],
      "source": [
        "print(z.power(3))\n",
        "print(z.power(1/3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "svnz7ZEulkH4"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "celltoolbar": "Diaporama",
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.9.13"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}