evo_temp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Partie II - Evolution temporelle\n",
    "\n",
    "Ici, on utilise l'algorithme d'Euler explicite pour obtenir l'évolution temporelle de la fonction d'onde. Cet algorithme, bien que simple à utiliser, n'est pas très efficace.\n",
    "\n",
    "Lors de la partie 1, on utilisait un Hamiltonien à valeurs réelles, ici nous sommes obligés d'utiliser des valeurs complexes.\n",
    "\n",
    "Imaginons que l'on obtienne un hamiltonien complexe $\\psi(x)$ sous la forme d'un array numpy"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.linalg import eigh_tridiagonal\n",
    "from matplotlib.animation import PillowWriter\n",
    "from numba import njit\n",
    "from time import perf_counter\n",
    "\n",
    "# On définit d'abord les constantes dx et dt.\n",
    "N = 400\n",
    "L = 50\n",
    "dx = 2*L/(N-1)\n",
    "\n",
    "M = 2000\n",
    "T = 2\n",
    "dt = T/(M-1)\n",
    "dt_approx = np.format_float_scientific(dt, precision = 1, exp_digits=1)\n",
    "\n",
    "# Puis x tel que \n",
    "\n",
    "x = np.linspace(-L,L,N)\n",
    "\n",
    "print(\"dt= \",dt)\n",
    "print(\"dx= \",dx)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "id": "1cb0ddb5",
   "metadata": {},
   "source": [
    "On réitère ensuite la formation d'un hamiltionien vu lors de la partie 1 pour un potentiel nul"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ffd180d",
   "metadata": {},
   "outputs": [],
   "source": [
    "V_nul = np.zeros(N) #potentiel nul\n",
    "\n",
    "@njit\n",
    "def get_matrice(potentiel):\n",
    "    \"\"\"\n",
    "    Return d the diagonal and e the eigh-diagonal of H from a potential\n",
    "    :param potentiel: potential to give\n",
    "    :return: d,e diagonal and eigh-diagonal\n",
    "    \"\"\"\n",
    "\n",
    "    d = np.zeros(N)\n",
    "    e = np.zeros(N-1)\n",
    "\n",
    "    for i in range(potentiel.size):\n",
    "        d[i] = 2/(dx**2) + potentiel[i]\n",
    "\n",
    "    for i in range(e.size):\n",
    "        e[i] = -1/(dx**2)\n",
    "        \n",
    "    return d,e\n",
    "\n",
    "@njit\n",
    "def normalize(m, deltax):\n",
    "    \"\"\"\n",
    "    Return the normalized np array, with the boundaries set to 0\n",
    "    :param m: array to normalize\n",
    "    :param deltax: the difference betweenn 2 x\n",
    "    :return: normalized np array\n",
    "    \"\"\"\n",
    "    m /= np.linalg.norm(m)\n",
    "    m /= np.sqrt(deltax)\n",
    "    m[0] = 0\n",
    "    m[-1] = 0\n",
    "    return m\n",
    "\n",
    "# On crée la fonction pour former les etats stationnaires à partir de V\n",
    "def get_psi_statio(potentiel):\n",
    "    \"\"\"\n",
    "    Return (w,v) with w the eigenvalues of H and v eigenvectors\n",
    "    :param potentiel: potential to find w and v\n",
    "    :return: (w,v)\n",
    "    \"\"\"\n",
    "    d,e = get_matrice(potentiel) #On récupère la matrice de la formule donné par l'équation (2)\n",
    "\n",
    "    ## Puis, on calcule w et v respectivement les valeurs propres et vecteurs propres de H\n",
    "    w, v = eigh_tridiagonal(d,e)\n",
    "    v0 = np.zeros((N,N))\n",
    "    for i in range(N):\n",
    "        for y in range(N):            #On échange ligne et colonnes\n",
    "            v0[i][y] = v[y][i]\n",
    "    # On doit désormais normaliser les vecteurs propres :\n",
    "    for vec in v0:\n",
    "        normalize(vec,dx)\n",
    "    return w,v0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c9de63e",
   "metadata": {},
   "source": [
    "Puis, on forme la matrice H complète à partir de ses valeurs tridiagonale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b277ae97",
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit\n",
    "def get_h(potentiel):\n",
    "    \"\"\"\n",
    "    Return H the matrix from the potential\n",
    "    :param potentiel: potential to get H\n",
    "    :return: H matrix (N,N)\n",
    "    \"\"\"\n",
    "    h = np.zeros((N,N))\n",
    "    d,e = get_matrice(potentiel)\n",
    "    # on ajoute les valeurs dans H\n",
    "    for i in range(N):\n",
    "        h[i][i] += d[i]\n",
    "        if i != N-1:\n",
    "            h[i][i+1] += e[i]\n",
    "            h[i+1][i] += e[i]\n",
    "    return h"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "365dbc45",
   "metadata": {},
   "source": [
    "On forme ensuite une liste de liste psi\\[t\\]\\[x\\] représentant toutes les valeurs de v (le vecteur de psi) pour tout t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "309d1b7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit\n",
    "def f(psi,potentiel):\n",
    "    \"\"\"\n",
    "    The method we get from the fonction of d/dt(psi)\n",
    "    :param psi: psi\n",
    "    :param potentiel: potential\n",
    "    :return: d/dt(psi)\n",
    "    \"\"\"\n",
    "    moins_i_H = (-1j*get_h(potentiel)).astype(np.complex64)\n",
    "    psi_np = psi.astype(np.complex64)\n",
    "    return np.dot(moins_i_H,psi_np)\n",
    "\n",
    "@njit\n",
    "def euler(psi,potentiel):\n",
    "    \"\"\"\n",
    "    The Euler method\n",
    "    :param psi: psi\n",
    "    :param potentiel: potential\n",
    "    :return: normalized version of Euler of psi\n",
    "    \"\"\"\n",
    "    new_psi = psi + dt*f(psi,potentiel)\n",
    "    return normalize(new_psi,dx)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54739e63",
   "metadata": {},
   "source": [
    "Enfin, on utilise la formule (7) du poly ce qui nous donne les valeurs de psi pour différents temps :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7934bb13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# On crée la fonction pour afficher les graphiques\n",
    "\n",
    "def get_graph(psi,potentiel,method,name,nb_dt):\n",
    "    \"\"\"\n",
    "    Return final graph, and save with number M, time nb_dt, and a chosen name\n",
    "    :param psi: initial psi\n",
    "    :param potentiel: potentiel of situation\n",
    "    :param method: method for solbing ODE\n",
    "    :param name: name to put on the graph\n",
    "    :param nb_dt: number of step to show\n",
    "    \"\"\"\n",
    "    for i in range(nb_dt):\n",
    "        psi = method(psi,potentiel)\n",
    "        plt.plot(x,abs(psi),label=\"Numérique $t=%i \\cdot dt$\" %i)\n",
    "    plt.xlabel('$x$')\n",
    "    plt.ylabel('$\\Psi(x)$')\n",
    "    plt.title('Norme de $\\Psi(x)$ en fonction de la position x durant %i dt (dt = %s)' %(nb_dt,dt_approx))\n",
    "    plt.savefig('docs/tempo/psi_fonction_de_x_%s_m%i_duree_%i.pdf' %(name,M,nb_dt),format='pdf',bbox_inches='tight')\n",
    "    plt.savefig('docs/tempo/psi_fonction_de_x_%s_m%i_duree_%i.jpeg' %(name,M,nb_dt),format='jpeg',bbox_inches='tight')\n",
    "    plt.show()\n",
    "\n",
    "w_test,v_test = get_psi_statio(V_nul)\n",
    "psi0 = v_test[0] #Première harmonique\n",
    "get_graph(psi0,V_nul,euler,\"euler_etat_statio0\",150)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "799cb4ef",
   "metadata": {},
   "source": [
    "Ici, nous allons reprendre le même processus mais avec un état initial sous forme d'un paquet d'onde d'une gaussienne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2158976",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_psi_gauss(x0,sigma,k):\n",
    "    \"\"\"\n",
    "    Get the Psi0 in a form of a gaussian wave paquet\n",
    "    :param x0: X where the gaussian is maximal\n",
    "    :param sigma: how large is the gaussian\n",
    "    :param k: wave vector\n",
    "    :return: psi0\n",
    "    \"\"\"\n",
    "    psi = np.zeros(N,dtype=complex)\n",
    "\n",
    "    for i in range(N):\n",
    "        inside_exp = -((x[i]-x0)**2)*(sigma**2)/4\n",
    "        psi[i] = np.exp(inside_exp)\n",
    "        psi[i] *= np.exp(1j*k*x[i])\n",
    "    psi = normalize(psi,dx)\n",
    "    return psi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2406c853-07a4-47d0-b977-bf6b35180260",
   "metadata": {},
   "outputs": [],
   "source": [
    "get_graph(get_psi_gauss(1,0.5,2),V_nul,euler,\"euler_gaussienne\",300)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12454106",
   "metadata": {},
   "source": [
    "On remarque ici que notre rendu n'est pas correct, ou alors est trop long. En effet l'algorithme d'Euler explicite ne nous permet pas d'être suffisament précis, nous allons donc mettre en oeuvre l'algorithme de Runge-Kutta d'ordre 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48e8047f",
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit\n",
    "def rk4(psi,potentiel):\n",
    "    \"\"\"\n",
    "    RK4 method\n",
    "    :param psi: psi\n",
    "    :param potentiel: potential\n",
    "    :return: rk4 of psi\n",
    "    \"\"\"\n",
    "    k1 = f(psi,potentiel)\n",
    "    k2 = f(psi + k1 * dt / 2.,potentiel)\n",
    "    k3 = f(psi + k2 * dt / 2.,potentiel)\n",
    "    k4 = f(psi + k3 * dt,potentiel)\n",
    "    new_psi = psi + (dt / 6.)*(k1 + 2*k2 + 2*k3 + k4)\n",
    "    new_psi = new_psi.astype(np.complex64)\n",
    "    return normalize(new_psi,dx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80a10845",
   "metadata": {},
   "outputs": [],
   "source": [
    "get_graph(get_psi_gauss(1,0.5,2),V_nul,rk4,\"rk4_gaussienne\",150)\n",
    "get_graph(psi0,V_nul,rk4,\"rk4_etat_statio0\",150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f4e3d13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ------------ ANIMATION -------------- #\n",
    "def get_anim_diff_between_methods(psi_init_1,psi_init_2,potentiel,xmax,final_time,step,name,print_pot):\n",
    "    \"\"\"\n",
    "    Save a gif named anim_RK4 with a specific name that compare euler and RK4\n",
    "    :param xmax: get the graph to plot from -xmax to xmax\n",
    "    :param final_time: Final t to get the animation\n",
    "    :param psi_init_1: Initial psi for RK4\n",
    "    :param psi_init_2: Initial psi for Euler\n",
    "    :param potentiel: Total potential\n",
    "    :param step: save a image each [step] itérations\n",
    "    :param name: name to add to the file\n",
    "    :param print_pot: boolean - true if you want the potential to be on the graph\n",
    "    \"\"\"\n",
    "\n",
    "    start = perf_counter()\n",
    "\n",
    "    metadata = dict(title='test', artist='lucas')\n",
    "    writer = PillowWriter(fps=60, metadata=metadata)\n",
    "\n",
    "    fig = plt.figure()\n",
    "    plt.xlim(-xmax, xmax)\n",
    "    plt.ylim(-0.5, 2)\n",
    "\n",
    "    t = 0\n",
    "    t_approx = np.format_float_scientific(t, precision = 2, exp_digits=1)\n",
    "\n",
    "    plt.xlabel('$x$')\n",
    "    plt.ylabel('$\\\\Psi(x)$')\n",
    "    plt.title('Norme de $\\\\Psi(x)$ en fonction de la position x (t = %s)' % t_approx)\n",
    "\n",
    "    if print_pot:\n",
    "        pot, = plt.plot(x,potentiel,linestyle='dotted',label=\"Potentiel\")\n",
    "\n",
    "    l, = plt.plot(x,abs(psi_init_1),label=\"RK4\")\n",
    "    l2, = plt.plot(x,abs(psi_init_2), label=\"Euler\")\n",
    "\n",
    "    plt.legend()\n",
    "\n",
    "    new_psi1 = psi_init_1\n",
    "    new_psi2 = psi_init_2\n",
    "\n",
    "    with writer.saving(fig, \"docs/tempo/anim_%s_M_%s.gif\"%(name,M), 100):\n",
    "        for i in range(final_time):\n",
    "            new_psi1 = rk4(new_psi1,potentiel)\n",
    "            new_psi2 = euler(new_psi2,potentiel)\n",
    "\n",
    "            t += dt\n",
    "\n",
    "            if i%step == 0:\n",
    "\n",
    "                l.set_data(x,abs(new_psi1))\n",
    "                l2.set_data(x,abs(new_psi2))\n",
    "\n",
    "                t_approx = np.format_float_scientific(t, precision = 2, exp_digits=1)\n",
    "                plt.title('Norme de $\\\\Psi(x)$ en fonction de la position x (t = %s) pour un dt=%s' % (t_approx,dt_approx))\n",
    "\n",
    "                writer.grab_frame()\n",
    "    plt.show()\n",
    "\n",
    "    end = perf_counter()\n",
    "    print(\"Elapsed (after compilation) = {}s\".format((end - start)))\n",
    "# ------------ FIN ANIMATION -------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "get_anim_diff_between_methods(get_psi_gauss(1,1,3),get_psi_gauss(-1,1,-3),V_nul,L,M,100,\"gauss_pot_nul_séparé\",False)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "On va maintenant essayer de former un vecteur d'état initial étant une combinaison d'états stationnaires puis voir la différence entre le résultat numérique et théorique"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "w_nul,v_nul = get_psi_statio(V_nul)\n",
    "\n",
    "def get_sum_vect_initial(eigenvectors,dict_vect):\n",
    "    \"\"\"\n",
    "    Return a vector made of harmonics of the potential (stationary states)\n",
    "    :param eigenvectors: stationary state array\n",
    "    :param dict_vect: dictionary of sum for the final vect ( Ex : {0:1,2:3} -> 1*v[0] + 3*v[2] )\n",
    "    :return: sum of stationary states given by the dictionary dict_vect\n",
    "    \"\"\"\n",
    "    final_v = np.zeros(N)\n",
    "    for p,val in dict_vect.items():\n",
    "        final_v += eigenvectors[p]*val\n",
    "    return final_v\n",
    "\n",
    "def theorical_time_passing(eigenvectors,eigenvalues,dict_vect,t):\n",
    "    \"\"\"\n",
    "    Return the new vector for the t value\n",
    "    :param eigenvectors: stationary state array\n",
    "    :param eigenvalues: stationary state value of energy\n",
    "    :param dict_vect: dictionary of sum for the final vect ( Ex : {0:1,2:3} -> 1*v[0] + 3*v[2] )\n",
    "    :param t: value of time\n",
    "    :return: Return the new vector for the t value\n",
    "    \"\"\"\n",
    "    psi = np.zeros(N)\n",
    "    for p,val in dict_vect.items():\n",
    "        psi += val*eigenvectors[p]*np.exp(-eigenvalues[p]*t)\n",
    "        psi = psi.astype(np.complex64)\n",
    "    return normalize(psi,dx)\n",
    "\n",
    "plt.xlim(-20, 20)\n",
    "plt.ylim(-0.5, 2)\n",
    "for i in range(100):\n",
    "    plt.plot(x,abs(theorical_time_passing(v_nul,w_nul,{1:10,10:10},i/10)))\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# ------------ ANIMATION -------------- #\n",
    "def get_anim_diff_theorical_with_statio(dict_statio,eigenvalues,eigenvectors,method_theorical,potentiel,xmax,final_time,step,name,print_pot):\n",
    "    \"\"\"\n",
    "\n",
    "    Save a gif with a specific name that compare RK4 and theorical sum of stationnary states with time\n",
    "    :param method_theorical: method to get the theorical value\n",
    "    :param eigenvectors: stationary state array\n",
    "    :param eigenvalues: stationary state value of energy\n",
    "    :param dict_statio: dictionary of sum for the final vect ( Ex : {0:1,2:3} -> 1*v[0] + 3*v[2] )\n",
    "    :param xmax: get the limits of the graph to plot\n",
    "    :param final_time: Final t to get the animation\n",
    "    :param potentiel: Total potential\n",
    "    :param step: save a image each [step] itérations\n",
    "    :param name: name to add to the file\n",
    "    :param print_pot: boolean - true if you want the potential to be on the graph\n",
    "    \"\"\"\n",
    "\n",
    "    start = perf_counter()\n",
    "\n",
    "    metadata = dict(title='test', artist='lucas')\n",
    "    writer = PillowWriter(fps=60, metadata=metadata)\n",
    "\n",
    "    fig = plt.figure()\n",
    "    plt.xlim(-xmax, xmax)\n",
    "    plt.ylim(0, 0.2)\n",
    "\n",
    "    t = 0\n",
    "    t_approx = np.format_float_scientific(t, precision = 2, exp_digits=1)\n",
    "\n",
    "    plt.xlabel('$x$')\n",
    "    plt.ylabel('$\\\\Psi(x)$')\n",
    "    plt.title('Norme de $\\\\Psi(x)$ en fonction de la position x (t = %s)' % t_approx)\n",
    "\n",
    "    if print_pot:\n",
    "        pot, = plt.plot(x,potentiel,label=\"Potentiel\")\n",
    "\n",
    "    l, = plt.plot(x,abs(get_sum_vect_initial(eigenvectors,dict_statio))**2,label=\"RK4\")\n",
    "    l2, = plt.plot(x,abs(get_sum_vect_initial(eigenvectors,dict_statio))**2, label=\"Theorical\")\n",
    "\n",
    "    plt.legend()\n",
    "\n",
    "    new_psi1 = get_sum_vect_initial(eigenvectors,dict_statio).astype(np.complex64)\n",
    "\n",
    "    with writer.saving(fig, \"docs/tempo/anim_%s.gif\"%name, 100):\n",
    "        for i in range(final_time):\n",
    "\n",
    "            t += dt\n",
    "\n",
    "            new_psi1 = rk4(new_psi1,potentiel)\n",
    "            new_psi2 = method_theorical(eigenvectors,eigenvalues,dict_statio,t)\n",
    "\n",
    "            if i%step == 0:\n",
    "\n",
    "                l.set_data(x,abs(new_psi1))\n",
    "                l2.set_data(x,abs(new_psi2))\n",
    "\n",
    "                t_approx = np.format_float_scientific(t, precision = 2, exp_digits=1)\n",
    "                plt.title('Norme de $\\\\Psi(x)$ en fonction de la position x (t = %s) pour un dt=%s' % (t_approx,dt_approx))\n",
    "\n",
    "                writer.grab_frame()\n",
    "    plt.savefig('docs/tempo/somme_statio_5000.png',format='png',bbox_inches='tight')\n",
    "    plt.show()\n",
    "    end = perf_counter()\n",
    "    print(\"Elapsed (after compilation) = {}s\".format((end - start)))\n",
    "# ------------ FIN ANIMATION -------------- #"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "get_anim_diff_theorical_with_statio({1:2,2:1},w_nul,v_nul,theorical_time_passing,V_nul,L,M,10,\"stationnaire_diff_theorical2\",False)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Prenons désormais un potentiel harmonique puis un potentiel sous forme de double puit harmonique"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def get_pot_harmonique(omega):\n",
    "    \"\"\"\n",
    "    Return an array for a harmonic potential\n",
    "    :param omega: the value of omega in the harmonic potential\n",
    "    :return: Numpy Array\n",
    "    \"\"\"\n",
    "    pot_harmo = np.zeros(N)\n",
    "    for i in range(N):\n",
    "        pot_harmo[i] = (omega**2 * x[i]**2) / 2\n",
    "    return pot_harmo\n",
    "\n",
    "get_anim_diff_between_methods(get_psi_gauss(1,2,0),get_psi_gauss(1,2,0),get_pot_harmonique(1),5,M,10,\"gauss_potentiel_harmo_identique\",True)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def get_pot_double_puit(x0,omega):\n",
    "    \"\"\"\n",
    "    Return an array for a double barrier potential from a to b with val value\n",
    "    :param x0: value of x0 in the harmonic\n",
    "    :param omega: value of omega in the harmonic\n",
    "    :return: Numpy Array\n",
    "    \"\"\"\n",
    "    pot_db_puit = np.zeros(N)\n",
    "    for i in range(N):\n",
    "        if x[i]<0:\n",
    "            pot_db_puit[i] = (omega**2 * (x[i]+x0)**2) / 2\n",
    "        else:\n",
    "            pot_db_puit[i] = (omega**2 * (x[i]-x0)**2) / 2\n",
    "    return pot_db_puit"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "get_anim_diff_between_methods(get_psi_gauss(-2,4,0),np.zeros(N),get_pot_double_puit(2,1),5,M,10,\"gauss_potentiel_double_puit\",True)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "id": "42da2d83",
   "metadata": {},
   "source": [
    "### Sources :\n",
    " - https://www.f-legrand.fr/scidoc/docmml/numerique/euler/euler/euler.html\n",
    " - https://www.youtube.com/watch?v=tsK72kSgPoI\n",
    " - https://www.moonbooks.org/Articles/How-to-create-a-matrix-of-complex-numbers-in-python-using-numpy-/\n",
    " - https://femto-physique.fr/analyse-numerique/runge-kutta.php\n",
    " - https://numba.readthedocs.io/en/stable/user/5minguide.html#will-numba-work-for-my-code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "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": 5
}