S2_TD2_python_notebook_en_teacher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F1WI4b8ShUv1"
   },
   "source": [
    "# <span style=\"color:blue\"> <center>Teacher / TD2 : 4TPU279U $-$ Bachelor 1st year $-$ spring 2023</center></span>\n",
    "# <center>Introduction to python programming</center>\n",
    "# <hr style=\"border:1px solid black\"><center>  Advanced basics </center><hr style=\"border:1px solid black\">\n",
    "</br>\n",
    "\n",
    "<div style=\"text-align: right\"> Credits: R. Boisgard, L. Truflandier, Philippe Paillou, Julien Burgin, Sara Zein, Leo Delmarre, Simon Villain-Guillot </div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following topics will be cover in this notebook:\n",
    "- Function\n",
    "- Python intrinsic functions\n",
    "- Libraries\n",
    "- Printing format\n",
    "- Numpy array\n",
    "- Functions and array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vl2lC9VXhUv7"
   },
   "source": [
    "## <hr style=\"border:1px solid black\">  Function  <hr style=\"border:1px solid black\">\n",
    "\n",
    "In computer programming, a [function](https://en.wikipedia.org/wiki/Function_(computer_programming)) is a sequence of instructions that performs a specific task, packaged as a unit (or block). This unit can then be used in programs wherever that particular task should be performed.\n",
    "\n",
    "Functions may be defined within *programs*, or separately in *libraries* that can be used by many programs. In different programming languages, a function may be called a *routine*, *subprogram*, *subroutine*, *method*, or more generally a *procedure*.\n",
    "\n",
    "In python we referred to as a function or when embedded in a class as a *method* (*vide infra*). The syntax for a python function is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9KrnFE-qhUv8"
   },
   "outputs": [],
   "source": [
    "def name( arguments ):\n",
    "    statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z7A_p77ShUv-"
   },
   "source": [
    "> ***name*** is the name of the function. As for variables, it should respect some basic syntaxic rules  (cf. TD1).\n",
    "\n",
    "> ***arguments*** is a collection of values which are involved in managing the instructions. The collection may be empty. If several arguments are introduced, they must be separated by a coma. In any case, the parenthesis are mandatory. As for the basis constructs, the colon symbol closes the function header.\n",
    "\n",
    "> ***statements*** is a set of instructions which are performed when the function is called. They must be *indented* from `def` by 4 spaces. Take-care: non-indented statements are said to be *outside* the function,\n",
    "they are not part of the function! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d3Oj3IWBhUv_"
   },
   "source": [
    "Sometimes, we want the function to return some result, as below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "R7ERDaVzhUwA"
   },
   "outputs": [],
   "source": [
    "def name( arguments ):\n",
    "    statements\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pAzU28XOhUwC"
   },
   "source": [
    "Let's have for some abstract function of one single argument $x$: $f(x)=3x^2 - 2x^3$. We want this function to print the result of $f(x)$. An example is given below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mido3oBZhUwE"
   },
   "outputs": [],
   "source": [
    "def func(x):\n",
    "    print(3*x**2 - 2*x**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YsdDi6ADhUwE"
   },
   "source": [
    "Having defined the function `func` we need to *call it* in order to *run it*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x90T6EF0hUwF"
   },
   "source": [
    "> for $x\\in\\mathbb{R}$, say $x=3.0$ let's call $f(x)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Xfw5nFZMhUwG"
   },
   "outputs": [],
   "source": [
    "func(x=3.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WFmGK2U6hUwG"
   },
   "source": [
    "> Now let's try with $x\\in\\mathbb{B}$ (Remember, in that case, `True` and `False` are converted to 1 and 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aI1wsF7MhUwG"
   },
   "outputs": [],
   "source": [
    "func(x=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "avkhLkXKhUwH"
   },
   "source": [
    "> What will happen with a list ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7atv5QEMhUwH"
   },
   "outputs": [],
   "source": [
    "#func(x=[0,1,-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KzkxvsOAhUwH"
   },
   "source": [
    "##### Exercise 2.0 <hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yW6xvO5thUwI"
   },
   "source": [
    "> Using a `for` loop compute and print $f(x)$ over the list elements $x=[0,1,-1]$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9DmOgZlphUwI"
   },
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UiWXUOKwhUwI"
   },
   "outputs": [],
   "source": [
    "for x in [0,1,-1]:\n",
    "    func(x=x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DtOW2KZChUwJ"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8F1GByvvhUwJ"
   },
   "source": [
    "If now, we want the function to return the result we will write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Vhpwjvu9hUwJ"
   },
   "outputs": [],
   "source": [
    "def func(x):\n",
    "    result = 3*x**2 - 2*x**3\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M74gXE2uhUwK"
   },
   "source": [
    "> Note that for such simple function the statement $3x^2-2x^3$ can be put straight after `return`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0lqfKh3OhUwK"
   },
   "outputs": [],
   "source": [
    "def func(x):\n",
    "    return 3*x**2 - 2*x**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2UECLI5ghUwK"
   },
   "source": [
    "> When calling the function we can ask to store the result in a new variable, such as: $y=f(x)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Q3JQ0dzjhUwL"
   },
   "outputs": [],
   "source": [
    "y = func(x=1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Tf1WW2R6hUwL"
   },
   "source": [
    "##### Exercise 2.1 <hr style=\"border:1px solid grey\">\n",
    "\n",
    "For each function below : $$f(x)=4x^2\\exp(-2x)$$ \n",
    "\n",
    "$$g(x)=\\frac{x^2}{2}\\left(1-\\frac{x}{2}\\right)^2\\exp(-x)$$\n",
    "\n",
    "$$h(x)= \\frac{4x^2}{243}\\left(3 - 2x + \\frac{2}{9}x^2\\right)^2 \\exp\\left(-\\frac{2x}{3}\\right)$$\n",
    "\n",
    "0. Define a function called `func_f`, `func_g` and `func_h`, respectively with $x$ as argument.\n",
    "1. Compute $f(x=1)$, $g(x=2)$. \n",
    "2. It turns out that $f(x=1)$ is a the $\\max$ of $f$ and $g(x=2)$ is a $\\min$ for $g$. Is it expected ?\n",
    "2. Compute $h(x)$ for $x_{+}=-\\frac{3}{2}\\left(\\sqrt{3}-3\\right)$ and $x_-=\\frac{3}{2}\\left(\\sqrt{3}+3\\right)$.\n",
    "2. Using the code of **Exercice 1.8** in **TD1** compute the roots of $h(x)$ and compare to $x_{+}$ and $x_{-}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q2nWBhdihUwL"
   },
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "swJ4dhZ-hUwL"
   },
   "outputs": [],
   "source": [
    "from numpy import exp, infty, sqrt\n",
    "#from scipy.integrate import quad\n",
    "\n",
    "def func_f(x):\n",
    "    return 4*x**2 * exp(-2*x)\n",
    "\n",
    "def func_g(x):\n",
    "    return x**2/2 * (1 - x/2)**2 * exp(-x)\n",
    "\n",
    "def func_h(x):\n",
    "    return 4*x**2/243 * (3 - 2*x + 2/9*x**2)**2 * exp(-2*x/3)\n",
    "\n",
    "# Should be normalized ; just for checking\n",
    "#print(quad(func_f,0,infty))\n",
    "#print(quad(func_g,0,infty))\n",
    "#print(quad(func_h,0,infty))\n",
    "\n",
    "print( func_f(x=1) )\n",
    "print( func_g(x=2) )\n",
    "print( func_h(x=-3/2*(sqrt(3) - 3)) )\n",
    "print( func_h(x= 3/2*(sqrt(3) + 3)) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r9LLG7owhUwM"
   },
   "source": [
    "Note : Concerning the $\\max_{x=1}f(x)$ and $\\min_{x=2}g(x)$ : you may compute first and second derivative but that's a bit lengthy. Better is to remark that $f(x)$ and $g(x)$ (as well as $h(x)$) are positive definite. For $f(x)$ by computing $f'(x=1)=0$ we know that it is a $\\max$ which must be framed by 2 $\\min$ ($\\forall x\\in[0,+\\infty[$) ; the first $\\min$ is at $x=0$ and the second is found for $x\\rightarrow +\\infty$. For $g(x)$ this is even easier with the fact the for $g(x)\\geq 0$ $\\forall x$, then $0$ must be a (global) minimum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uJ2o7YS9hUwM"
   },
   "outputs": [],
   "source": [
    "#a = 1 ; b = -1 ; c = -1\n",
    "#a = 1 ; b = -1 ; c =  1\n",
    "a = 2/9 ; b = -2 ; c =  3\n",
    "\n",
    "delta = b**2 - 4*a*c\n",
    "\n",
    "if ( delta > 0 ):\n",
    "    xp = (-b + sqrt(delta))/(2*a)\n",
    "    xm = (-b - sqrt(delta))/(2*a)\n",
    "    print('There are 2 real roots:')\n",
    "    print('x_p =',xp)\n",
    "    print('x_m =',xm)\n",
    "\n",
    "if ( delta == 0 ):\n",
    "    xp = -b/(2*a)\n",
    "    xm = xp\n",
    "    print('There is 1 real root:')\n",
    "    print('x =',xp)\n",
    "    \n",
    "if ( delta < 0 ):\n",
    "    xp = (-b + sqrt(-delta)*1j)/(2*a)\n",
    "    xm = (-b - sqrt(-delta)*1j)/(2*a)\n",
    "    print('There are 2 imaginary roots:')\n",
    "    print('z_p =',xp)\n",
    "    print('z_m =',xm)\n",
    "\n",
    "    \n",
    "print( 3/2*(sqrt(3) + 3))\n",
    "print(-3/2*(sqrt(3) - 3))\n",
    "\n",
    "print('ax^2+ bx + c = 0 ?', a*xp**2 + b*xp + c)\n",
    "print('ax^2+ bx + c = 0 ?', a*xm**2 + b*xm + c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pdMhiOmvhUwM"
   },
   "source": [
    "## <hr style=\"border:1px solid black\">  Python intrinsic (built-in) functions  <hr style=\"border:1px solid black\">\n",
    "\n",
    "Python comes with a set of [built-in functions](https://docs.python.org/3/library/functions.html). \n",
    "\n",
    "- Basic mathematical functions are given below. \n",
    "\n",
    "> In the example, $x=[-11,-10,...,0,1,2,...,10]$ and we search for : $\\max x$, $\\min x$ and $|\\min x|$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rvjj54wzhUwN"
   },
   "outputs": [],
   "source": [
    "x = list(range(-11,11))\n",
    "print(x)\n",
    "max_val = max(x)\n",
    "min_val = min(x)\n",
    "abs_val = abs(min_val)\n",
    "\n",
    "print('the max  is: ', max_val)\n",
    "print('the min  is: ', min_val)\n",
    "print('abs(min) is: ', abs_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nKSI_sv5hUwN"
   },
   "source": [
    "> for $x=1.6$ and $y=1.4$ we search for $\\lfloor x\\rceil$ and $\\lfloor y\\rceil$, ie. the nearest integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pvcz5o9thUwN"
   },
   "outputs": [],
   "source": [
    "x = 1.6\n",
    "y = 1.4\n",
    "print('x =',x, '=> round(x) =', round(x))\n",
    "print('y =',y, '=> round(y) =', round(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6MT_K7cbhUwN"
   },
   "source": [
    "- `zip` to iterate over several lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sdxcHGo-hUwN"
   },
   "outputs": [],
   "source": [
    "days = ['monday','tuesday','wednesday','thursday','friday','saturday','sunday']\n",
    "num  = list(range(1,8))\n",
    "\n",
    "for item in zip(num,days):\n",
    "    print(item)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yP7coWCshUwO"
   },
   "source": [
    "##### Exercice 2.2 : <hr style=\"border:1px solid grey\">\n",
    "Review all the build-in functions already used in **TD1** and give an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EPEQudZbhUwO"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Jpswy_ArhUwO"
   },
   "source": [
    "## <hr style=\"border:1px solid black\"> Libraries  <hr style=\"border:1px solid black\">\n",
    "\n",
    "- [Numpy](https://numpy.org/doc/stable/index.html) = Numerical Python : library containing the basic numerical tools and the `array` class\n",
    "- [Scipy](https://docs.scipy.org/doc/scipy/index.html) = Scientific Python : for advanced algorithms including linear algebra, numerical PDE and integration, fitting, optimisation, Fourier transform...\n",
    "- [Matplotlib](https://matplotlib.org) = Mathematical plotting library : for plotting in 1D/2D(3D)\n",
    "\n",
    "### There are 3 basic ways of using a library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E6AORiIXhUwP"
   },
   "source": [
    "> import straight the library using `import`. Then points towards the function you need.\n",
    "> Here the sinus function is imported and executed as `numpy.sin(x)` where $x$ is any real number. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i2gnv4qqhUwP"
   },
   "outputs": [],
   "source": [
    "import numpy\n",
    "numpy.sin(0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8_tHEQPehUwP"
   },
   "source": [
    "> import the library and assign an *alias* ; here `np`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vKxQ-Z1khUwP"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.sin(0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NekfxWI0hUwP"
   },
   "source": [
    "> import explicitely the funtion using `from *library_name* import *the_function*`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZOK8Y6nahUwQ"
   },
   "outputs": [],
   "source": [
    "from numpy import sin\n",
    "sin(0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nVnbLsSchUwQ"
   },
   "source": [
    "### Library scipy.constants for physical and mathematical constants and units.\n",
    "\n",
    "> This library [scipy.constants](https://docs.scipy.org/doc/scipy/reference/constants.html) gives access to all the fundamental constants internationally recommended by [CODATA](https://physics.nist.gov/cuu/Constants/index.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MvBRVLNchUwQ"
   },
   "outputs": [],
   "source": [
    "from scipy.constants import h, c, e, epsilon_0\n",
    "from scipy.constants import unit\n",
    "\n",
    "print('Planck constant   = ',h)\n",
    "print('speed of light    = ',c)\n",
    "print('elementary charge = ',e)\n",
    "print()\n",
    "print('Planck constant   = ',h, unit('Planck constant'))\n",
    "print('speed of light    = ',c, unit('speed of light in vacuum'))\n",
    "print('elementary charge = ',e, unit('elementary charge'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vzqPuy1BhUwQ"
   },
   "source": [
    "> you can search through the dictionnary using the `find()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bTzx2Oe-hUwQ"
   },
   "outputs": [],
   "source": [
    "from scipy.constants import find, physical_constants\n",
    "\n",
    "name = find('speed of light')\n",
    "print(name)\n",
    "\n",
    "value, unit, uncertainty = physical_constants[name[0]]\n",
    "print(value, unit, uncertainty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vhTfnAcwhUwR"
   },
   "outputs": [],
   "source": [
    "from scipy.constants import giga, femto, yotta, inch, foot, angstrom\n",
    "\n",
    "print('giga   =',giga)   \n",
    "print('femto  =',femto)    \n",
    "print('yotta  =',yotta)    \n",
    "print('1 inch =',inch,'m')    \n",
    "print('1 foot =',foot,'m')   \n",
    "print('1 Anstrom =',angstrom,'m')   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercice 2.3 : <hr style=\"border:1px solid grey\">\n",
    "From the library `scipy.constants` :\n",
    "1. find the value of the electric permittivity in vacuum and print it along with the unit\n",
    "1. find the value of the distance atomic unit and print it along with the unit\n",
    "1. find the conversion factor from eV to Joule and print it "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.constants import find, physical_constants\n",
    "\n",
    "find('permittivity')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "value, unit, uncertainty = physical_constants['vacuum electric permittivity']\n",
    "print(value, unit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find('atomic unit')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "value, unit, uncertainty = physical_constants['atomic unit of length']\n",
    "print(value, unit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find('electron volt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "value, unit, uncertainty = physical_constants['electron volt-joule relationship']\n",
    "print(value, unit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oPGAjxfKhUwR"
   },
   "source": [
    "## <hr style=\"border:1px solid black\"> Printing format  <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_aFZoAOnhUwR"
   },
   "source": [
    "> unformatted print of the Planck constant $h$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "df_K8Q8QhUwR"
   },
   "outputs": [],
   "source": [
    "from scipy.constants import h\n",
    "\n",
    "print('Planck constant = ',h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N_i2jsuBhUwR"
   },
   "source": [
    "> formatted print using scientific notation $\\{e\\}$ :\n",
    "\n",
    "> $\\{$%$\\}$ indicate where to print the number in the characters string\n",
    "\n",
    "> $\\{$12.4$\\}$ = length of 12 characters (total) with 4 decimals \n",
    "\n",
    "> Warning : remember that `6.6261e-34` means $6.6261\\times 10^{-34}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RZW8rL4GhUwS"
   },
   "outputs": [],
   "source": [
    "print('Planck constant = %12.4e '%h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7nu_CBM9hUwS"
   },
   "source": [
    "> You can let python adapts the length of the scientific number by typing $\\{$.4e$\\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BffuazjmhUwS"
   },
   "outputs": [],
   "source": [
    "print('Planck constant = %.4e '%h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GUr9HZSMhUwS"
   },
   "outputs": [],
   "source": [
    "print('Planck constant = %.4e J.s'%h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UzToe2NEhUwS"
   },
   "source": [
    "> $\\{$s$\\}$ is used for strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "05LrCXKphUwS"
   },
   "outputs": [],
   "source": [
    "print('Planck constant = %.4e %s'%(h,'J.s'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D_TcDJ2GhUwT"
   },
   "source": [
    "> formatted print using floating point notation $\\{f\\}$ :  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Wp3phf1vhUwT"
   },
   "outputs": [],
   "source": [
    "from scipy.constants import c\n",
    "\n",
    "print('speed of light = ',c)\n",
    "print('speed of light = %20.4f'%c)\n",
    "print('speed of light = %.4f'%c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a2ou6XCthUwT"
   },
   "source": [
    "##### Exercice 2.4 : constants <hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t1gJX5c_hUwT"
   },
   "source": [
    "Using the `scipy.constants` module:\n",
    "\n",
    "- Compute the force between two electrons separated by $r=1$ Ang. using the Coulomb law:\n",
    "$$||\\vec{F}_C||  = \\frac{1}{4\\pi\\epsilon_0}\\frac{q_e^2}{r^2}$$\n",
    "- Compute the Rybderg constant $$R_H=\\frac{mq_e^4}{8\\varepsilon^2_0h^3c}$$ where \n",
    "  - $\\epsilon_0$ is the vacuum electric permittivity\n",
    "  - $q_e$ the elementary charge\n",
    "  -  $m$ the electron mass\n",
    "  - $h$ is the Planck constant\n",
    "  - $c$ the speed of light\n",
    "\n",
    "- Compare to the Rydberg constant implemented in `scipy.constants` as `Rydberg`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ohC7pTuyhUwU"
   },
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "53ES_H6XhUwU"
   },
   "outputs": [],
   "source": [
    "from scipy.constants import c, h, epsilon_0, e, pi, electron_mass, Rydberg\n",
    "from scipy.constants import electron_mass as m_e\n",
    "\n",
    "r = 1e-10\n",
    "F = 1/(4*pi*epsilon_0)*e**2/r**2\n",
    "print('FCoulomb = %.4e N'%F)\n",
    "\n",
    "RH = m_e*e**4/(8*epsilon_0**2*h**3*c)\n",
    "print('RH       = %.8f'%RH)\n",
    "print('Rydberg  = %.8f'%Rydberg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yGSccNQ3hUwU"
   },
   "source": [
    "## <hr style=\"border:1px solid black\">  Numpy array  <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XttBktB0hUwU"
   },
   "source": [
    "### `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Zg4MBc5YhUwU"
   },
   "outputs": [],
   "source": [
    "L1 = [1,20,3.14,1+3j]\n",
    "L2 = [2.5,'toto', L1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NT206UqEhUwU"
   },
   "outputs": [],
   "source": [
    "print(L1,L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "I9QxmH4thUwU"
   },
   "outputs": [],
   "source": [
    "type(L1), type(L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "w9TKwn6FhUwV"
   },
   "outputs": [],
   "source": [
    "print(L1+L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oANS85W2hUwV"
   },
   "source": [
    "### `array`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "79fP7fxQhUwV"
   },
   "source": [
    "> build an `array` from a `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pCa-2MY0hUwV"
   },
   "outputs": [],
   "source": [
    "from numpy import array, pi, zeros\n",
    "\n",
    "L = [5,pi/2,6.3] \n",
    "print(L, type(L))\n",
    "\n",
    "A = array(L)\n",
    "print(A, type(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s8OlbTWXhUwV"
   },
   "source": [
    "> build and initialize an `array` with zeros or ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fv685SEIhUwV"
   },
   "outputs": [],
   "source": [
    "from numpy import zeros, ones\n",
    "\n",
    "A = zeros((4))\n",
    "print(A, type(A))\n",
    "\n",
    "B = ones((4))\n",
    "print(B,type(B))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GTymC0eNhUwV"
   },
   "source": [
    "### Differences between a `list` and an `array`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ay5i4nYQhUwW"
   },
   "outputs": [],
   "source": [
    "L1 = [3,6,2]\n",
    "L2 = [8,1,4]\n",
    "print(L1)\n",
    "print(L2)\n",
    "\n",
    "L = L1+L2\n",
    "print(L)\n",
    "\n",
    "L = L1*4\n",
    "print (L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "of40fpfFhUwW"
   },
   "outputs": [],
   "source": [
    "A1 = array(L1)\n",
    "A2 = array(L2)\n",
    "A  = A1+A2\n",
    "print(A)\n",
    "\n",
    "B = A1*A2\n",
    "print(B)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jjJlCEGbhUwW"
   },
   "source": [
    "### Function `arange`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Uik762PuhUwW"
   },
   "source": [
    "> arange($x_{inf}$, $x_{sup}$, $\\delta$) with $\\delta$ the step\n",
    "\n",
    "> create an `array` of floats $x\\in[x_{inf},x_{sup}[$\n",
    "such that $x=\\{x_{inf},\\;x_{inf}+\\delta,\\;x_{inf}+2\\delta,...\\}$\n",
    "\n",
    "> it stops before $x_{sup}$ !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WTi1Jw6jhUwW"
   },
   "outputs": [],
   "source": [
    "from numpy import arange\n",
    "\n",
    "A = arange(2,3,0.2)\n",
    "print(A,type(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OXCfV8bihUwW"
   },
   "source": [
    "### Function `linspace`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y2yM1k6ghUwX"
   },
   "source": [
    "> linspace($x_{inf}$, $x_{sup}$, $n$) with $n$ an integer\n",
    "\n",
    "> create an `array` of floats $x\\in[x_{inf},x_{sup}]$\n",
    "\n",
    "> such that $x=\\{x_{inf},\\;x_{inf}+\\delta,\\;x_{inf}+2\\delta,...,x_{sup}\\}$ and $\\delta=\\frac{x_{sup}-x_{inf}}{n-1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3CXo9-9vhUwX"
   },
   "outputs": [],
   "source": [
    "from numpy import linspace\n",
    "\n",
    "A = linspace(0,10,6)\n",
    "print(A,type(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lygYU8X1hUwX"
   },
   "source": [
    "### Accessing 1D `array` elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BDtjzDsGhUwX"
   },
   "source": [
    "> print the entire array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GE6VaImthUwX"
   },
   "outputs": [],
   "source": [
    "from numpy import linspace\n",
    "\n",
    "x = linspace(2,12,6) \n",
    "print(x)\n",
    "print(x[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tqNRra8ThUwX"
   },
   "source": [
    "> print only some elements by the index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bFZX-YRthUwX"
   },
   "outputs": [],
   "source": [
    "print(x[0], x[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TBcpptfDhUwX"
   },
   "source": [
    "> from $n=3$ (included) to $5$ (excluded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6Brtvy5XhUwX"
   },
   "outputs": [],
   "source": [
    "print(x[3:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6LILjdIQhUwY"
   },
   "source": [
    "> from $n=3$ (excluded) to the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JdlMrpubhUwY"
   },
   "outputs": [],
   "source": [
    "print(x[3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z7QFv58YhUwY"
   },
   "source": [
    "> from the beginning to $n=3$ (included) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8_RnloNGhUwY"
   },
   "outputs": [],
   "source": [
    "print(x[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6MWOl9bthUwY"
   },
   "source": [
    "> print the last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RZqZb6KzhUwY"
   },
   "outputs": [],
   "source": [
    "print(x[-1]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5v1cju-XhUwY"
   },
   "source": [
    "### Accessing 2D `array` elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c3fYn_cChUwY"
   },
   "source": [
    "> let's have: $M\\in\\mathbb{N}^{3\\times 3}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-zEOOI-ThUwY"
   },
   "outputs": [],
   "source": [
    "from numpy import array\n",
    "\n",
    "M = array([[1,   2,  3],\n",
    "           [10, 11, 12],\n",
    "           [20, 21, 22]])\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mRlg4EC-hUwZ"
   },
   "source": [
    "> print the first row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "o3ZnbGAxhUwZ"
   },
   "outputs": [],
   "source": [
    "print(M[0,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UROnSBr5hUwZ"
   },
   "source": [
    "> print the first column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1a8jLVh2hUwZ"
   },
   "outputs": [],
   "source": [
    "print(M[:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UQDlkoMjhUwZ"
   },
   "source": [
    "> print an element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eZEF2rNchUwZ"
   },
   "outputs": [],
   "source": [
    "print(M[1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LWr18LMghUwZ"
   },
   "source": [
    "## <hr style=\"border:1px solid black\"> Function and array  <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QyRQrC8jhUwa"
   },
   "source": [
    "> Let's have for some abstract $x$: $f(x;a,b)=a\\times x + b$ where $x$ is the variable and $(a,b)$ some parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-kR7jHgHhUwa"
   },
   "outputs": [],
   "source": [
    "def func(x,a,b):\n",
    "    y = a*x + b\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6Db6OuodhUwa"
   },
   "source": [
    "> for $x\\in\\mathbb{R}$, say $x=3.2$ and $(a=2.0,b=1.0)$, let's compute $f(x)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3Trlwe2HhUwa"
   },
   "outputs": [],
   "source": [
    "# print result straight in standard output\n",
    "func(x=3.2,a=2.0,b=1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2_evxipchUwa"
   },
   "outputs": [],
   "source": [
    "# store result in a variable\n",
    "c = func(x=3.2,a=2.0,b=1.0)\n",
    "print(c)\n",
    "\n",
    "# implicit assignment of arguments\n",
    "c = func(3.2,2.0,1.0)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g1p5-r6fhUwa"
   },
   "source": [
    "> for $v\\in\\mathbb{R}^{3}$, with $(a=2.0,b=1.0)$, let's compute $f(v)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XENgAnDfhUwa"
   },
   "outputs": [],
   "source": [
    "from numpy import array\n",
    "\n",
    "v = array([1,2,3])\n",
    "y = func(x=v,a=2.0,b=1.0)\n",
    "\n",
    "print('v vector:')\n",
    "print(v)\n",
    "print('y vector:')\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "peSyJaBShUwb"
   },
   "source": [
    "> we found that if $v\\in\\mathbb{R}^{3}$ then $f(v)\\in\\mathbb{R}^{3}$ ! Note that $b$ does not need to be a vector !\n",
    "\n",
    "> `python` has interpreted: $a\\times v + b\\times o$ with $o=[1,1,1]$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FbOFuwyjhUwb"
   },
   "source": [
    "##### Exercice 2.5 : vector norm <hr style=\"border:1px solid grey\">\n",
    "Given $v\\in\\mathbb{R^{3}}$, write a function which computes $||v||$ ; compare to the function `norm`\n",
    "from the library `numpy.linalg`.\n",
    "\n",
    "Compute $||a||$, $||b||$, $||c||$ using $a=(1/\\sqrt{2},\\; 0,\\: -1/\\sqrt{2})$, $b=(1/\\sqrt{6},\\; -2/\\sqrt{6},\\: 1/\\sqrt{6})$ and\n",
    "$c=(1/\\sqrt{3},\\; 1/\\sqrt{3},\\: 1/\\sqrt{3})$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1mmJ7AGAhUwb"
   },
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zxN_ijdqhUwb"
   },
   "outputs": [],
   "source": [
    "from numpy.linalg import norm\n",
    "from numpy import sqrt, array\n",
    "    \n",
    "def my_norm(v):\n",
    "    res = 0.0\n",
    "    for i in range(len(v)):\n",
    "        res = res + v[i]**2\n",
    "    # or\n",
    "    #return sqrt(sum(b**2))\n",
    "    return sqrt(res)\n",
    "\n",
    "a = array([1/sqrt(2),       0.0, -1/sqrt(2)])\n",
    "b = array([1/sqrt(6),-2/sqrt(6),  1/sqrt(6)])\n",
    "c = array([1/sqrt(3), 1/sqrt(3),  1/sqrt(3)])\n",
    "\n",
    "na = my_norm(v=a)\n",
    "print(na)    \n",
    "print(norm(x=a))\n",
    "\n",
    "nb = my_norm(v=b)\n",
    "print(nb)    \n",
    "\n",
    "nc = my_norm(v=c)\n",
    "print(nc)    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J2fFa8XphUwb"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u7a1JQtnhUwb"
   },
   "source": [
    "##### Exercice 2.6 : inner product (= dot product) <hr style=\"border:1px solid grey\">\n",
    "Given $(v,w)\\in\\mathbb{R^{3}}$, write a function wich computes $v\\cdot w$ ; compare to the function `inner`\n",
    "from the library `numpy`.\n",
    "\n",
    "Compute $a\\cdot b$, $b\\cdot c$ and $a\\cdot c$ with $a=(1/\\sqrt{2},\\; 0,\\: -1/\\sqrt{2})$, $b=(1/\\sqrt{6},\\; -2/\\sqrt{6},\\: 1/\\sqrt{6})$ and\n",
    "$c=(1/\\sqrt{3},\\; 1/\\sqrt{3},\\: 1/\\sqrt{3})$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zf1wgDoPhUwb"
   },
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cmc0ncdShUwc"
   },
   "outputs": [],
   "source": [
    "from numpy import array, inner\n",
    "\n",
    "def my_inner(v,w):\n",
    "    res = 0.0\n",
    "    for i in range(len(v)):\n",
    "        res = res + v[i]*w[i]\n",
    "    return res\n",
    "\n",
    "a = array([1/sqrt(2),       0.0, -1/sqrt(2)])\n",
    "b = array([1/sqrt(6),-2/sqrt(6),  1/sqrt(6)])\n",
    "c = array([1/sqrt(3), 1/sqrt(3),  1/sqrt(3)])\n",
    "\n",
    "print(my_inner(v=a,w=b), inner(a,b))\n",
    "print(my_inner(v=b,w=c), inner(b,c))\n",
    "print(my_inner(v=a,w=c), inner(a,c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sWyoUpeHhUwc"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x3i4_itEhUwc"
   },
   "source": [
    "##### Exercice 2.7 : externalize the function in a `python` file <hr style=\"border:1px solid grey\">\n",
    "\n",
    "0. Create a new `python` file named `my_lib.py` using **Anaconda/Spyder**.\n",
    "1. Copy the function `my_norm` and `my_inner` into that file.\n",
    "2. Save the file at the same location than the jupyter-notebook file.\n",
    "3. Import `my_norm` and `my_inner` from `my_lib` and test them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BSXXH9NXhUwc"
   },
   "outputs": [],
   "source": [
    "from my_lib import my_norm, my_inner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aQhh0aCghUwc"
   },
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "g36_2Hf2hUwd",
    "outputId": "8a9369af-78cb-4e9e-eb08-ef92314c0b8e"
   },
   "outputs": [],
   "source": [
    "from numpy  import array, sqrt\n",
    "from my_lib import my_norm, my_inner\n",
    "\n",
    "a = array([1/sqrt(2),       0.0, -1/sqrt(2)])\n",
    "b = array([1/sqrt(6),-2/sqrt(6),  1/sqrt(6)])\n",
    "c = array([1/sqrt(3), 1/sqrt(3),  1/sqrt(3)])\n",
    "\n",
    "print(my_norm(v=a))\n",
    "print(my_inner(v=a,w=b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iW7MFdnUhUwd"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Diaporama",
  "colab": {
   "provenance": []
  },
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}