{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<H1 style=\"font-size:50px\">8: Grafici</H1>\n",
    "\n",
    "<div style = \"width:95%; padding:5px 10px 5px;  margin:50px 0px 10px 10px; font-size:18px\">\n",
    "<UL>\n",
    "    <LI> Come creare un oggetto grafico\n",
    "    <LI> Come disegnare un set di punti\n",
    "    <LI> Gli elementi di un grafico\n",
    "    <LI> Come disegnare una o più funzioni\n",
    "    <LI> Come fare plot logaritmici\n",
    "    <LI> Come fare gli istogrammi\n",
    "    <LI> Come salvare un plot su file\n",
    "    <LI> Cos'è e come fare un plot parametrico\n",
    "</UL>\n",
    "</div>\n",
    "\n",
    "<hr>\n",
    "\n",
    "## 8.1 Nozioni fondamentali\n",
    "Potete trovare una eccellente introduzione a Matplotlib nella Sezione 5 di<br/> \n",
    "[Robert Johanson - Scientific Computing with Python](http://raw.github.com/jrjohansson/scientific-python-lectures/master/Scientific-Computing-with-Python.pdf)<br/>\n",
    "Johanson utilizza lo stesso approccio \"object oriented\" che viene adottato in queste lezioni."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style= 'padding:20px 20px 0px 150px;'>\n",
    "    <img src=\"../Humour/MisleadingGraphs.jpg\" width=\"500\" align=\"center\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il modo più semplice per iniziare un grafico è la funzione `subplots`. La chiamata a `subplots` restituisce un oggetto di tipo `Figure`, che corrisponde alla pagina in cui il plot (o il gruppo di plot) è contenuto, e uno o più oggetti di tipo `AxesSubplot` che corrispondono ai singoli grafici. I plot si costruiscono applicando i metodi opportuni ai corrispondenti oggetti.<BR>\n",
    "In Jupyter il grafico viene mostrato quando si esegue la cella. Se non chiamiamo alcun metodo per costruire il grafico, viene mostrato un plot elementare con parametri di default.\n",
    "    \n",
    "Nella cella seguente l'oggetto di tipo `Figure` viene assegnato alla variabile `fig`. L'oggetto di tipo  `AxesSubplot` viene assegnato\n",
    "alla variabile `ax`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 5))\n",
    "print('fig:',type(fig))\n",
    "print(' ax:',type(ax))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nel caso ci siano più plot questi vengono assegnati ad una ntupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax_1,ax_2) = plt.subplots(nrows=1, ncols=2, figsize=(8, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax_1,ax_2) = plt.subplots(nrows=2, ncols=1, figsize=(8, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax_tuple = plt.subplots(nrows=2, ncols=1, figsize=(8, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.2 Plot di una lista di  numeri. Scatterplots\n",
    "Ciascuna curva nel grafico si genera con una chiamata al metodo `plot` applicato all'oggetto di tipo `AxesSubplot` restituito da `subplots`. Per disegnare set di punti si usa il metodo `scatter`. Sia `plot` che scatter richiedono un set di punti le cui coordinate (x,y) vengono passate in due `nd.array` oppure due `liste`. La prima lista contiene le coordinate x, la seconda le coordinate y. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(8, 5))\n",
    "ax1.plot(np.array([1,2,4,3]))   # Valori dell'ordinata. I valori dell'ascissa sono impliciti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(8, 5))\n",
    "ax1.plot(np.array([1,2,3,4]),np.array([1,4,9,16]))    # Valori dell'ascissa. Valori dell'ordinata."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(8, 5))\n",
    "ax1.scatter(np.array([1,2,3,4]),np.array([1,4,9,16]))    # Valori dell'ascissa. Valori dell'ordinata."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.3 Titoli, Nomi degli assi, Colori, LineStyle.\n",
    "\n",
    "&Egrave; possibile marcare i punti utlizzati in `plot` e `scatter` con un simbolo.\n",
    "`marker` determina il tipo simbolo usato ('o' corrisponde a pallini). `c` oppure `color` determina il colore del simbolo: 'b' significa blue (red: 'r', green: 'g', nero: '0', ). Nel caso di curve, `linestyle` determina il tipo di linea: per esempio `solid`, `dashed`, `dotted`, `dashdotted`. Nelle chiamate a `plot` di default non ci sono marker e i punti sono uniti da linee.<BR>\n",
    "I metodi `set_title`, `set_xlabel`, `set_ylabel` assegnano titoli al plot, all'asse delle ordinate, all'asse delle ascisse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig2, ax2 = plt.subplots(figsize=(5, 7)) \n",
    "ax2.set_ylabel('some function')\n",
    "ax2.set_xlabel('Some variable')\n",
    "ax2.set_title('ScatterPlot 1')\n",
    "ax2.scatter(np.array([1,2,3,4]),np.array([1,4,9,16]), marker='s', c='0') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig2, ax2 = plt.subplots(figsize=(5, 7)) \n",
    "ax2.set_ylabel('y')\n",
    "ax2.set_xlabel('x')\n",
    "ax2.set_title('Plot 1')\n",
    "ax2.plot(np.array([1,2,3,4]),np.array([1,4,9,16]), linestyle='dashed', color='red') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estremi degli assi\n",
    "Di default, Matplotlib sceglie gli estremi degli assi in modo che tutti i punti che vengono passati al comando `plot` o `scatterplot` siano visibili nel grafico. L'utente può però fissare gli estremi con `set_xlim`, `set_ylim`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "ax.plot(np.array([1,2,3,4]),np.array([1,4,9,16]), c='b', label='g1')\n",
    "ax.set_xlim(-1.,2.5)\n",
    "ax.set_ylim(-1.5,10.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Griglie\n",
    "\n",
    "Le griglie sono linee chiare, parallele agli assi coordinati, che facilitano la lettura delle coordinate dei punti di un grafico. Il default è che non vengano disegnate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "x = np.linspace(0,4,201)\n",
    "ax.plot(x,x*x)\n",
    "ax.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "help(ax.grid) per ulteriori informazioni"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linee verticali/orizzontali \n",
    "\n",
    "Si possono disegnare linee verticali oppure orizzontali con i metodi `vlines` e `hlines`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "x = np.linspace(-2,2,201)\n",
    "ax.plot(x,x**3)\n",
    "ax.hlines(1.,-2.,2.,colors='r')\n",
    "ax.vlines(-1.,-6.,4.,colors='0')\n",
    "ax.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.4 Fare il grafico di una funzione nota `f(x)`\n",
    "\n",
    "Il modo più semplice per fare il grafico di una funzione `f(x)`è:\n",
    "\n",
    "- Generare un set apportuno `xval` di ascisse in cui calcolare i valori di `f`, tipicamente usando `arange` o `linspace`.\n",
    "- Scrivere una funzione che restituisca i valori `yval` di `f(x)` nei punti `xval`.\n",
    "- Costruire il grafico usando il metodo plt.plot(xval,yval,......)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_f(x):\n",
    "    return 2*x**3 + 3*x**2 - 12*x -10\n",
    "\n",
    "xval = np.arange(-4,3,0.1)\n",
    "yval = my_f(xval)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8,6))\n",
    "\n",
    "ax.set_xlabel('x coordinate')\n",
    "ax.set_ylabel('my_f(x)')\n",
    "ax.set_title('Plot of my_f')\n",
    "ax.grid()\n",
    "\n",
    "ax.plot(xval,yval); # Il ; alla fine del comando plot elimina la stampa della locazione in memoria del plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style = \"width:95%; padding:5px 10px 5px; border-style:solid; border-width:0px 0px 0px 10px; border-color:#b8d0d0; margin:20px 0px 10px 10px\">\n",
    "    <h4> Imparare Facendo</h4>\n",
    "    \n",
    "<OL>\n",
    "<LI>Fate il grafico di y(x) = cos(x)/(x**2+1) nell'intervallo -5 < x < 2 usando una linea rossa. Introducete nomi opportuni per gli assi. Inserite una griglia per semplificare la lettura del plot.\n",
    "</OL>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.5 Plot multipli\n",
    "\n",
    "### Curve multiple in un singolo plot\n",
    "\n",
    "È sufficiente dare il comando `plot` su un singolo `ax` per tutte le curve da disegnare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0.0, 2*np.pi, 0.01)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12, 5))\n",
    "ax.plot(t,np.cos(t),c='r')\n",
    "ax.plot(t,np.cos(2*t),c='b')\n",
    "ax.plot(t,np.cos(10*t),c='g')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot multipli in una sola figura.\n",
    "\n",
    "È necessario creare, nella chiamata a `plt.subplots`, tanti oggetti di tipo `ax` quanti sono i plot che si vogliono ottenere.\n",
    "Ciascuno dei comandi successivi si riferirà ad uno specifico oggetto `ax`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(t):\n",
    "    return np.exp(-t) * np.cos(2*np.pi*t)\n",
    "t1 = np.arange(0.0, 5.0, 0.1)\n",
    "t2 = np.arange(0.0, 5.0, 0.02)\n",
    "\n",
    "fig3, (ax3a,ax3b) = plt.subplots(nrows=1, ncols=2, figsize=(14, 5))\n",
    "\n",
    "ax3a.plot(t1, f(t1),  marker='o', c='b')\n",
    "ax3a.set_xlabel('x value') \n",
    "ax3a.set_ylabel('f(x)') \n",
    "ax3a.set_title('Plot 1')\n",
    "\n",
    "ax3b.plot(t2, np.cos(2*np.pi*t2),  linestyle='--', c='r')\n",
    "ax3b.set_xlabel('x value') \n",
    "ax3b.set_ylabel('cos(2 pi x)') \n",
    "ax3b.set_title('Plot 2')\n",
    "\n",
    "fig3.tight_layout()\n",
    "\n",
    "# Percontrollare lo spazio fra i plot potete usare fig3.tight_layout(pad=3.6)\n",
    "# help(fig3.tight_layout) per ulteriori informazioni\n",
    "\n",
    "# linestyle='-','--',':'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per ottenere quattro plot in due file da due utilizzare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ((ax1,ax2),(ax3,ax4)) = plt.subplots(nrows=2, ncols=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un'altra possibilità è assegnare l'ntupla degli ax ad un unica variabile e poi utilizzare gli indici. In questo modo è possibile fare un ciclo `for` sui plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1, my_ax = plt.subplots(nrows=2, ncols=2)\n",
    "my_ax[0,1].plot(np.array([1,2,3])) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Titolo centrato per tutta la figura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1, my_ax = plt.subplots(nrows=2, ncols=2)\n",
    "my_ax[0,1].plot(np.array([1,2,3]))\n",
    "my_ax[0,1].set_title(\"One line\")\n",
    "plt.suptitle(\"Four Plots with one line\");\n",
    "fig1.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.6 Salvare una figura in un file\n",
    "\n",
    "L'estensione del file determina il formato in cui viene salvata la figura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig3.savefig('plot3.pdf')\n",
    "fig3.savefig('plot3.jpg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style = \"width:95%; padding:5px 10px 5px; border-style:solid; border-width:0px 0px 0px 10px; border-color:#b8d0d0; margin:20px 0px 10px 10px\">\n",
    "    <h4> Imparare Facendo</h4>\n",
    "    \n",
    "<OL>\n",
    "<LI>Fate il grafico di y1(x) = cos(x)/(x**2+1) e y2(x) = (cos(x)+x)/(x**2+1) nell'intervallo -5 < x < 2 in un unico plot. Introducete nomi opportuni per gli assi. Inserite una griglia per semplificare la lettura del plot.\n",
    "<LI>Fate il grafico di y1(x) = cos(x) e y2(x) = cos(x)+x nell'intervallo -2 < x < 2 in due plot affiancati. Utilizzate colori diversi per le due curve. Introducete nomi opportuni per gli assi di entrambi i plot.\n",
    "</OL>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.7 Plot logaritmici\n",
    "\n",
    "Per avere una scala logaritmica sull'asse `x`, `y` si usano i metodi `set_xscale('log')`, `set_yscale('log')` sugli oggetti di tipo `AxesSubplot`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig4, (ax4a,ax4b) = plt.subplots(nrows=1, ncols=2, figsize=(14, 7))\n",
    "\n",
    "t = np.arange(0.01, 20.0, 0.01)\n",
    "\n",
    "# log y axis\n",
    "ax4a.set_yscale('log')\n",
    "ax4a.plot(t, np.exp(-t/5.0))\n",
    "ax4a.set_xlabel('x value') \n",
    "ax4a.set_ylabel('exp(-t/5.0)') \n",
    "ax4a.set_title('semilogy')\n",
    "ax4a.grid(visible=True,which='both')   \n",
    "\n",
    "# log x axis\n",
    "ax4b.set_xscale('log')\n",
    "ax4b.plot(t, np.sin(2*np.pi*t))\n",
    "ax4b.set_xlabel('x value') \n",
    "ax4b.set_ylabel('sin(2*pi*t)') \n",
    "ax4b.set_title('semilogx')\n",
    "ax4b.grid(visible=True,which='both')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Di default vengono utilizzati logaritmi in base 10. È possibile specificare una base diversa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0.01, 20.0, 0.01)\n",
    "\n",
    "fig5, ax5 = plt.subplots(nrows=1, ncols=1, figsize=(7, 7))\n",
    "\n",
    "ax5.set_xscale('log',base=2)\n",
    "ax5.set_yscale('log')\n",
    "ax5.plot(t,t,c='r')\n",
    "ax5.plot(t,t**2,c='b')\n",
    "ax5.grid(visible=True,which='both')\n",
    "ax5.set_title('loglog base 2 on x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I plot logaritmici sono essenziali quando ordinate e/o ascisse variano su molti ordini di grandezza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0.01, 10.0, 0.01)\n",
    "\n",
    "fig6, (ax6a,ax6b) = plt.subplots(nrows=1, ncols=2, figsize=(10, 6))\n",
    "\n",
    "ax6a.plot(t,t,c='r')\n",
    "ax6a.plot(t,t**2,c='b')\n",
    "ax6a.plot(t,t**4)\n",
    "ax6a.set_title('linear')\n",
    "ax6a.grid(visible=True,which='both')\n",
    "\n",
    "ax6b.set_yscale('log')\n",
    "ax6b.plot(t,t,c='r')\n",
    "ax6b.plot(t,t**2,c='b')\n",
    "ax6b.plot(t,t**4)\n",
    "ax6b.set_title('y-log')\n",
    "ax6b.grid(visible=True,which='both')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style = \"width:95%; padding:5px 10px 5px; border-style:solid; border-width:0px 0px 0px 10px; border-color:#b8d0d0; margin:20px 0px 10px 10px\">\n",
    "    <h4> Imparare Facendo</h4>\n",
    "    \n",
    "<OL>\n",
    "<LI>Fate il grafico di y1(x) = np.e**(-x), y2(x) = np.e**(-2*x) nell'intervallo 0 < x < 10, in un unico plot, utilizzando una scala logaritmica per l'asse y. Introducete nomi opportuni per gli assi. Inserite una griglia per semplificare la lettura del plot.\n",
    "</OL>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.8 Istogrammi\n",
    "\n",
    "I dati sono raggruppati in bin (contenitori, bidoni). L'altezza di ciascun bin corrisponde al numero di dati che cadono fra i due valori della variabile che definiscono la base del bin. Cambiando il numero di bin e/o i loro estremi si cambia il plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dati = np.array([1.95,1.96,1.9,1.9,1.84,1.81,2.06,1.99,1.93,1.97,2.02,1.92,1.95,1.88,1.87,2.03,1.85,2.08,1.96,1.81,\n",
    "                2.07,1.91,1.79,1.99,1.97,1.95,1.96,1.93,1.83,2.09,2.02,2.09,1.84,1.86,1.96,2.03,1.93,1.9,1.94,1.87,\n",
    "                1.97,1.91,1.87,1.81,2.06,2.02,1.96,1.81,1.93,2.03,1.92,1.96,1.8,1.95,1.9,2.02,2.03,1.9,2.03,2.02,\n",
    "                1.96,1.9,1.98,1.87,1.9,1.89,1.84,2.06,1.93,2.06,1.93,1.93,1.9,1.9,1.9,1.93,1.86,1.83,1.96,1.81,2.03,\n",
    "                1.98,1.84,1.86,1.96,1.81,1.98,1.84,1.86,1.96,1.92,1.96,1.85,2.04,2,1.92,1.9,2.15,1.94,1.92])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nbins = 10\n",
    "xrange = (1.75,2.20)    # ntupla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "nevent, bins, patches = ax.hist(dati, nbins, range=xrange)     # Non è indispensabile assegnare i valori restituiti da `hist`  a\n",
    "   # delle variabili. In questo caso ci serve per esaminarne il contenuto.\n",
    "\n",
    "ax.set_xlabel('variable')\n",
    "ax.set_ylabel('counts')\n",
    "ax.set_title('counts vs variable')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nevent       # Numero di eventi in ciacun bin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bins         # Estremi dei bin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I patches sono i rettangoli (blu in questo caso) che vengono usati per disegnare l'istogramma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.9 Altri elementi dei plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Legende\n",
    "\n",
    "Basato su https://realpython.com/python-matplotlib-guide/<BR>\n",
    "\n",
    "La legenda per ciascuna curva viene passata con il parametro `label` nella chiamata a `plot`. Le curve prive di `label` non vengono incluse nella legenda.\n",
    "    Se nessuna delle curve ha un `label` si ha un errore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "xc = np.arange(-5.0, 5.0, 0.02)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g1(x):\n",
    "    return x*(x-1)/(x**2+1)-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "yc1 = g1(xc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g2(x):\n",
    "    return (x-1)/(x**2+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "yc2 = g2(xc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "ax.set_title('g1=x*(x-1)/(x**2+1)-1, g2=(x-1)/(x**2+1)',fontsize='20')\n",
    "ax.set_xlabel('x value')\n",
    "ax.set_ylabel('g(x)')\n",
    "ax.grid(True)\n",
    "ax.margins(x=0.,y=0.05)\n",
    "ax.plot(xc, yc1, c='b', label='pippo rules', linestyle = '--');\n",
    "ax.plot(xc, 3*yc2, 'k', label='g2');\n",
    "ax.plot(xc, yc2, c='g');\n",
    "ax.legend(fontsize='30');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il prefisso `r` davanti alle stringhe di testo inibisce l'interpretazione dei caratteri di \"escape\" come caratteri speciali. Importante perchè LaTeX usa il carattere \"\\\\\" per introdurre i comandi e \"\\\\\" è il carattere standard di \"escape\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f0(t, omega, gamma, tau):\n",
    "    wt = omega*t\n",
    "    f1 = np.sin(wt) + (np.cos(wt)-1.0)/wt\n",
    "    f2 = 1.0+(gamma/omega)*f1\n",
    "    return np.exp(-t*f2/tau)\n",
    "\n",
    "omega = 12.0\n",
    "gamma = 8.0\n",
    "tau = 1.0\n",
    "\n",
    "t = np.linspace(0.01, 10.0, 500)\n",
    "f = f0(t, omega, gamma, tau)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7.5, 4.5))\n",
    "ax.plot(t, f)\n",
    "ax.set_ylabel(r'$f_0(t)$', fontsize=14)\n",
    "#ax.set_ylabel('$f_0(t)$', fontsize=14)   # r è superfluo per questa stringa in cui non ci sono caratteri \"escape\"\n",
    "ax.set_xlabel(r'$t/\\tau\\quad\\rm(ms)}$', fontsize=14)\n",
    "#ax.set_xlabel('$t/\\tau\\quad\\rm(ms)}$', fontsize=14)       # r è necessario per questa stringa in cui compare \n",
    "                                                           # il carattere \"\\\" come parte di LaTeX\n",
    "plt.text(1.8, 0.85, r'$\\Gamma(z)=\\int_0^\\infty x^{z-1}e^{-x}dx$', {'color': 'k', 'fontsize': 14})\n",
    "plt.text(4.0, 0.4, r'$\\Gamma(z)=\\int_0^\\infty x^{z-1}e^{-x}dx$', {'color': 'b', 'fontsize': 20})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style = \"width:95%; padding:5px 10px 5px; border-style:solid; border-width:0px 0px 0px 10px; border-color:#b8d0d0; margin:20px 0px 10px 10px\">\n",
    "    <h4> Imparare Facendo</h4>\n",
    "    \n",
    "<OL>\n",
    "<LI>Fate l'istogramma dell'array a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]). Qual'è un <b>range</b> ragionevole? Variate il numero di bin fra 1 e 10.\n",
    "</OL>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_f(x):\n",
    "    return 2*x**3 + 3*x**2 - 12*x -10\n",
    "\n",
    "xval = np.arange(-4,3,0.1)\n",
    "yval = my_f(xval)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8,6))\n",
    "\n",
    "ax.set_xlabel('x coordinate')\n",
    "ax.set_ylabel('my_f(x)')\n",
    "ax.set_title('Plot of my_f')\n",
    "ax.grid()\n",
    "\n",
    "ax.plot(xval,yval); # Il ; alla fine del comando plot elimina la stampa della locazione in memoria del plot\n",
    "\n",
    "ax2 = plt.axes([0.3, 0.2, 0.3, 0.2]) # [x_left_lower_corner,y_left_lower_corner,x_width,y_width] in axis coordinates\n",
    "\n",
    "xval2 = np.arange(0,2*np.pi,0.1)\n",
    "yval2 = np.cos(xval2)\n",
    "ax2.grid()\n",
    "ax2.plot(xval2,yval2);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.10 Plot parametrici\n",
    "\n",
    "Spesso per descrivere una curva esprimiamo le coordinate `y` dei punti sulla curva in funzione delle loro coordinate `x`. Per esempio una semicirconferenza centrata nell'origine è descritta dalla relazione $ y(x) = \\sqrt{r^2 - x^2}$, dove $r$ è il raggio.<BR>\n",
    "Un modo alternativo di costruire i punti sul cerchio di raggio $r$ è di notare che possiamo usare come coordinata l'angolo del punto rispetto all'asse $\\hat{x}$ come:\n",
    "    $$ x(\\theta) = r \\cos\\theta,\\qquad y(\\theta) = r \\sin\\theta$$\n",
    "Se creiamo due array sufficientemente fitti in questo modo, possiamo disegnare una circonferenza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raggio = 3.\n",
    "npoints = 100\n",
    "step = 2*np.pi/npoints\n",
    "x0 = raggio*np.array([np.cos(i*step) for i in range(npoints+1)])\n",
    "y0 = raggio*np.array([np.sin(i*step) for i in range(npoints+1)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "ax.plot(x0, y0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Provate a vedere cosa succede per npoints = 3,4,8,12."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problema:\n",
    "---------\n",
    "\n",
    "Studiare la funzione $g(x)\\, = \\, \\cos \\left( \\frac{x^4 - 5 x^3 - 3 x^2 + 17 x - 10}{x^4 + 2 x^2 + 1} \\right)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style = \"width:95%; padding:5px 10px 5px; border-style:solid; border-width:0px 0px 0px 10px; border-color:#ff0000; margin:20px 0px 10px 10px\">\n",
    "    <h4> Attenzione!</h4>\n",
    "La possibilità di fare il grafico di una qualsiasi funzione con pochissima fatica richiede di cambiare completamente l'approccio che vi è stato insegnato alle scuole superiori sul modo di studiare le funzioni. Fare il grafico deve diventare il passo preliminare a qualsiasi altra manipolazione.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Informazini addizionali e buoni esempi: https://www.machinelearningplus.com/plots/matplotlib-tutorial-complete-guide-python-plot-examples/"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "17px",
    "width": "160px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}