Notes/Introduzione a NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ba4de2d7",
   "metadata": {},
   "source": [
    "# **Introduzione a NumPy**\n",
    "## *Algebra Polinomi e Statistica*\n",
    "Introduzione ed esercizi sulla classe **numpy** e i rispettivi moduli **linalg** e **polynomial**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f6f653f",
   "metadata": {},
   "source": [
    "## **Operazioni Fondamentali**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "306ba453",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importazione dei moduli di interesse\n",
    "import numpy as np\n",
    "from numpy import linalg\n",
    "import numpy.polynomial.polynomial as poly\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d467d020",
   "metadata": {},
   "source": [
    "Gli **array** sono la struttura dati principale di NumPy:\n",
    "\n",
    "- Rappresentano un generico *tensore*\n",
    "- Sono composti da elementi *omogenei* \n",
    "- Possono essere sia monodimensionali, sia n-dimensionali\n",
    "\n",
    "Possiamo valutarne le dimensioni mediante la proprietà `shape`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fca17b17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 6)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3, 4, 5, 6],[1,0,0,0,0,0]])\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f83195c6",
   "metadata": {},
   "source": [
    "Esistono diversi metodi per la creazione rapida di un array\n",
    "- `ones` creo un array di tutti 1\n",
    "- `zeros` creo un array di tutti 0\n",
    "- `empty` creo un array non inizializzato\n",
    "- `eye` creo la matrice identità"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "27e4bee9",
   "metadata": {},
   "outputs": [],
   "source": [
    "u = np.ones(shape=(3,3)) # creo un array di tutti 1\n",
    "z = np.zeros(shape=(3,3)) # creo un array di tutti 0\n",
    "e = np.empty(shape=(3,3)) # creo un array non inizializzato\n",
    "i = np.eye(3) # creo la matrice identità"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b68e62ae",
   "metadata": {},
   "source": [
    "Il metodo `diag(x)` permette di:\n",
    "- estrarre la diagonale se x è una matrice;\n",
    "- ottenere una matrice diagonale con x diagonale se x è un vettore."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "155fb6fe",
   "metadata": {},
   "source": [
    "## **Algebra**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "759357e2",
   "metadata": {},
   "source": [
    "Per calcolare la **trasposta** di una matrice, usiamo la funzione `transpose`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e04c7427",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Faccio una prova di transposta di una matrice rettangolare\n",
    "m1 = np.array([[1,2,3],[4,5,6]])\n",
    "np.transpose(m1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c3bb394",
   "metadata": {},
   "source": [
    "Per calcolare l'**inversa** di una matrice, usiamo la funzione `inv` del package `linalg`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "aec83c19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.        , 0.        ],\n",
       "       [0.        , 0.2       , 0.        ],\n",
       "       [0.        , 0.        , 0.33333333]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Uso linalg.inv(matrice) per verificare se una matrice è invertibile o no\n",
    "# Una condizione necessaria e sufficiente è che la matrice sia innanzittutto\n",
    "# quadrata e poi che il determinante sia diverso da zero\n",
    "\n",
    "m2 = np.array([[1,0,0],[0,5,0],[0,0,3]])\n",
    "linalg.inv(m2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06feb988",
   "metadata": {},
   "source": [
    "Se proviamo a calcolare l'inversa di una matrice rettangolare o di una matrice singolare, la funzione `inv` restituirà un errore di tipo `LinAlgError`. Uso di `try` and `except`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "49b4d348",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Errore\n",
      "Questo è ciò che accade se usiamo una matrice rettangolare!\n"
     ]
    }
   ],
   "source": [
    "# Proviamo a gestire un'eccezione con il costrutto \"try except as\"\n",
    "# Se sappiamo il tipo di errore che può presentarsi possiamo metterlo al posto di \"Exception\"\n",
    "# Se l'errore è particolare, bisogna importare la libreria degli errori della classe specifica, ad esempio:\n",
    "# import numpy.exception()\n",
    "\n",
    "m3 = np.array([[1,2,3],[2,4,6],[5,2,12]])\n",
    "try:\n",
    "    linalg.inv(m3)\n",
    "except Exception as e:\n",
    "    print(\"Errore\")\n",
    "\n",
    "# Oppure\n",
    "try:\n",
    "    np.linalg.inv(m3)\n",
    "except np.linalg.LinAlgError:\n",
    "    print('Questo è ciò che accade se usiamo una matrice rettangolare!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adf35a09",
   "metadata": {},
   "source": [
    "Usiamo la funzione `inner` per calcolare il prodotto **scalare** tra due vettori. Partiamo con un caso monodimensionale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "dc38044e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5, 6])\n",
    "\n",
    "np.inner(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07a722a1",
   "metadata": {},
   "source": [
    "Vediamo cosa accade in un caso **multidimensionale**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b64499ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1],\n",
       "       [4, 3]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[0, 1], [1, 0]])\n",
    "\n",
    "np.inner(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca110ecd",
   "metadata": {},
   "source": [
    "In questo caso, la formulazione è del tipo:\n",
    "\n",
    "$$\n",
    "p = \\left[\n",
    "    \\begin{array}{cc}\n",
    "        a_1 * b_1 + a_2 * b_2 & a_1 * b_3 + a_2 * b_4 \\\\\n",
    "        a_3 * b_1 + a_4 * b_2 & a_3 * b_3 + a_4 * b_4\n",
    "    \\end{array}\n",
    "\\right] = \\\\\n",
    "=\\left[\n",
    "    \\begin{array}{cc}\n",
    "        1 * 0 + 2 * 1 && 1 * 1 + 2 * 0 \\\\\n",
    "        3 * 0 + 4 * 1 && 3 * 1 + 4 * 0\n",
    "    \\end{array}\n",
    "\\right]\n",
    "= \\left[\n",
    "    \\begin{array}{cc}\n",
    "        2 & 1 \\\\\n",
    "        4 & 3\n",
    "    \\end{array}\n",
    "\\right]\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d856b3b",
   "metadata": {},
   "source": [
    "Il prodotto **esterno** viene calcolato mediante la funzione `outer`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "236483d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 4],\n",
       "       [6, 8]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2])\n",
    "b = np.array([3, 4])\n",
    "\n",
    "np.outer(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee6093a8",
   "metadata": {},
   "source": [
    "La funzione `matmul` ci permette di effettuare il **prodotto matriciale** tra due matrici."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "365b3829",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[19, 22],\n",
       "       [43, 50]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "np.matmul(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8e471d6",
   "metadata": {},
   "source": [
    "Per **elevare la matrice a potenza** utilizzare la funzione `matrix_power` del package `linalg`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3f408d83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1069, 1558],\n",
       "       [2337, 3406]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.matrix_power(a, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c99f2730",
   "metadata": {},
   "source": [
    "Per effettuare la **decomposizione ai valori singolari**. Tale processo è una tecnica di **riduzione della\n",
    "dimensionalità**. Consiste nello scomporre la matrice iniziale in tre diverse sottomatrici e si basa sul concetto di *trasformazione lineare*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2ce2da76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "u: [[-0.40455358 -0.9145143 ]\n",
      " [-0.9145143   0.40455358]] \n",
      "s: [5.4649857  0.36596619] \n",
      "v: [[-0.57604844 -0.81741556]\n",
      " [ 0.81741556 -0.57604844]]\n"
     ]
    }
   ],
   "source": [
    "(u, s, v) = np.linalg.svd(a)\n",
    "print('u:', u, '\\ns:', s, '\\nv:', v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2478b108",
   "metadata": {},
   "source": [
    "Per calcolare **autovettori ed autovalori** di una matrice, usiamo la funzione `eig` del package `linalg`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0aa45904",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Autovalori: [-0.37228132  5.37228132] \n",
      "Autovettori: [[-0.82456484 -0.41597356]\n",
      " [ 0.56576746 -0.90937671]]\n"
     ]
    }
   ],
   "source": [
    "(w, v) = np.linalg.eig(a)\n",
    "print('Autovalori:', w, '\\nAutovettori:', v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7d4977e",
   "metadata": {},
   "source": [
    "Per calcolare la norma, usiamo la funzione `norm`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "891340a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.477225575051661"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "112e532f",
   "metadata": {},
   "source": [
    "Per calcolare *rango*, *determinante* e *traccia*, usiamo rispettivamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "550b501d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rango: 2 \n",
      "Determinante: -2.0000000000000004 \n",
      "Traccia: 5\n"
     ]
    }
   ],
   "source": [
    "# Rango:\n",
    "rank = np.linalg.matrix_rank(a)\n",
    "\n",
    "# Determinante\n",
    "det = np.linalg.det(a)\n",
    "\n",
    "# Traccia\n",
    "tr = np.trace(a)\n",
    "\n",
    "print('Rango:', rank, '\\nDeterminante:', det, '\\nTraccia:', tr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b300b536",
   "metadata": {},
   "source": [
    "Per risolvere il seguente sistema di equazioni lineari:\n",
    "\n",
    "$$\n",
    "\\begin{cases}\n",
    "x_1 + 2 x_2 + 5 x_3 = y \\\\\n",
    "2 x_1 + 2 x_2 + 3 x_3 = 3 y \\\\\n",
    "2 x_1 + 2 x_2 + x_3 = 2 y\n",
    "\\end{cases}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "714b300e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.  , -3.75,  3.25])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[1, 2, 2], [2, 2, 2], [5, 3, 1]])\n",
    "y = np.array([1, 3, 2])\n",
    "\n",
    "np.linalg.solve(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5004d76",
   "metadata": {},
   "source": [
    "## **Polinomi**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bb4a9b2",
   "metadata": {},
   "source": [
    "Per rappresentare un polinomio, usiamo un oggetto di classe `poly1d()`. Esso è caratterizzato da un vettore di coefficienti.\n",
    "\n",
    "Per **sommare** due polinomi, usiamo la funzione `polyadd(p1, p2)`.\n",
    "\n",
    "Per **sottrarre** due polinomi, usiamo la funzione `polysub(p1, p2)`.\n",
    "\n",
    "Analogamente abbiamo `polymul(p1, p2)` (**moltiplicazione**), `polydiv(p1, p2)` (**divisione**) e `polypow(p, pow)` (**elevazione a potenza**).\n",
    "\n",
    "Proviamo a considerare:\n",
    " \n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{cases}\n",
    "c_1 = 2x + 1 \\\\\n",
    "c_2 = x^2 + 3x + 2 \\\\\n",
    "c_3 = x^2 + x\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "Allora:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ca49d9b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Somma di c1 e c2:\n",
      "    2\n",
      "3 x + 4 x + 2 \n",
      "Somma di c1 e c3:\n",
      "  \n",
      "3 x + 2\n"
     ]
    }
   ],
   "source": [
    "c1 = np.poly1d((0, 2, 1))\n",
    "c2 = np.poly1d((1, 3, 2))\n",
    "c3 = np.poly1d((1, 1, 0))\n",
    "p1 = poly.polyadd(c1, c2) # In uscita ho un array\n",
    "p2 = poly.polyadd(c1, c3)\n",
    "\n",
    "print('Somma di c1 e c2:\\n', np.poly1d(p1), '\\nSomma di c1 e c3:\\n', np.poly1d(p2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1190513e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sottrazione di c1 a c2:\n",
      "     2\n",
      "-1 x + 2 x + 2\n"
     ]
    }
   ],
   "source": [
    "print('Sottrazione di c1 a c2:\\n', np.poly1d(poly.polysub(c2, c1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3177e5ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prodotto tra c1 e c3:\n",
      "    2\n",
      "1 x + 3 x + 2 \n",
      "Quoziente tra c3 e c1:\n",
      "  \n",
      "-1 \n",
      "Resto tra c3 e c1:\n",
      "  \n",
      "1\n"
     ]
    }
   ],
   "source": [
    "p_mul = poly.polymul(c1, c3)[-1::-1]\n",
    "p_div = poly.polydiv(c3, c1)[-1::-1]\n",
    "print(\n",
    "    'Prodotto tra c1 e c3:\\n',\n",
    "    np.poly1d(p_mul),\n",
    "    '\\nQuoziente tra c3 e c1:\\n',\n",
    "    np.poly1d(p_div[0]),\n",
    "    '\\nResto tra c3 e c1:\\n',\n",
    "    np.poly1d(p_div[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e269d219",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c1 al quadrato è pari a:\n",
      "    2\n",
      "1 x + 4 x + 4\n"
     ]
    }
   ],
   "source": [
    "p_pow = poly.polypow(c1, 2)[-1::-1]\n",
    "print('c1 al quadrato è pari a:\\n', np.poly1d(p_pow))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fb29e64",
   "metadata": {},
   "source": [
    "Valutiamo i valori assunti dal polinomio `c1` in  $x =0, 1, 2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cd75181a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Per x = 0, c1 vale: 2.0 \n",
      "Per x = 1, c1 vale: 3.0 \n",
      "Per x = 2, c1 vale: 4.0\n"
     ]
    }
   ],
   "source": [
    "vals = poly.polyval([0, 1, 2], c1)\n",
    "\n",
    "print(\n",
    "    'Per x = 0, c1 vale:', vals[0],\n",
    "    '\\nPer x = 1, c1 vale:', vals[1],\n",
    "    '\\nPer x = 2, c1 vale:', vals[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62c38a60",
   "metadata": {},
   "source": [
    "Per calcolare la **derivata** e l'**integrale** di un polinomio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9fabade4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La derivata di c1 è:  \n",
      "2\n",
      "L'integrale indefinito di c1 è:    2\n",
      "1 x + 1 x\n"
     ]
    }
   ],
   "source": [
    "p_der_one = poly.polyder(c1.coeffs[-1::-1])\n",
    "print('La derivata di c1 è:', np.poly1d(p_der_one))\n",
    "\n",
    "p_int = poly.polyint(c1.coeffs[-1::-1])[-1::-1]\n",
    "print('L\\'integrale indefinito di c1 è:', np.poly1d(p_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4732293",
   "metadata": {},
   "source": [
    "## **Statistica**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "048256b5",
   "metadata": {},
   "source": [
    "Il **k – percentile** di un vettore 𝑉 di lunghezza 𝑁 è definito come il valore pari a $\\frac{k}{100}$\n",
    "calcolato a partire da una copia\n",
    "ordinata di 𝑉.\n",
    "Ad esempio considerati $100$ numeri ordinati, il *10-percentile* è 10, ossia tutti gli elementi sotto al 10. Ossia in generale il *k-percentile* è il $k-percento$ degli elementi ordinati sul vettore \n",
    "\n",
    "Esistono diversi modi di calcolare il *k – percentile* in NumPy ci mette a disposizione la funzione `percentile()`\n",
    "\n",
    "Il **quantile** è sostanzialmente analogo al percentile con valori normalizzati. Per calcolarlo ci offre la funzione\n",
    "`quantile()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "612426ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.5\n",
      "5.5\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,5,6,7])\n",
    "print(np.percentile(v,50))\n",
    "print(np.quantile(v,.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8ebf0ea",
   "metadata": {},
   "source": [
    "La **media** degli elementi di un array può essere calcolata in due modi.\n",
    "- Il primo prevede il calcolo puramente aritmetico mediante la funzione `mean()`\n",
    "- Il secondo usa una media pesata mediante la funzione `average()`\n",
    "Inoltre esistono anche delle funzioni per calcolare **deviazione standard** e **varianza**: `std()` `var()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "751114b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.5\n",
      "7.25\n",
      "7.433034373659253\n",
      "55.25\n"
     ]
    }
   ],
   "source": [
    "a = np.array([5, 12, 22, 3])\n",
    "\n",
    "print(np.mean(a))\n",
    "print(np.average(a, weights=[3, 1, 1, 3]))\n",
    "print(np.std(a))\n",
    "print(np.var(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d9af144",
   "metadata": {},
   "source": [
    "Ad esempio per calcolare il *percentile* ed il *quantile*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "27398752",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 8 77 65 43 43 85  8 69 20  9 52 97 73 76 71 78 51 12 83 45 50 37 18 92\n",
      " 78 64 40 82 54 44 45 22  9 55 88  6 85 82 27 63 16 75 70 35  6 97 44 89\n",
      " 67 77]\n",
      "25-percentile di c: 35.5\n",
      "75-quantile di c: 77.0\n"
     ]
    }
   ],
   "source": [
    "rng = np.random.default_rng(42) # Generatore casuale\n",
    "c = rng.integers(low=0, high=100, size=50)\n",
    "print(c)\n",
    "print('25-percentile di c:', np.percentile(c, 25))\n",
    "print('75-quantile di c:', np.quantile(c, .75))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "507b942d",
   "metadata": {},
   "source": [
    "Vediamo la matrice di covarianza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "425ca096",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_1:\n",
      " [[1 2 3]\n",
      " [4 5 6]] \n",
      "\n",
      "Matrice di covarianza:\n",
      " [[1. 1.]\n",
      " [1. 1.]]\n",
      "\n",
      "x_2:\n",
      " [[ 1  2  3]\n",
      " [-1 -2 -3]] \n",
      "\n",
      "Matrice di covarianza:\n",
      " [[ 1. -1.]\n",
      " [-1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "x_corr = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print('x_1:\\n', x_corr, '\\n')\n",
    "print('Matrice di covarianza:\\n', np.cov(x_corr))\n",
    "x_anticorr = np.array([[1, 2, 3], [-1, -2, -3]])\n",
    "print('\\nx_2:\\n', x_anticorr, '\\n')\n",
    "print('Matrice di covarianza:\\n', np.cov(x_anticorr))"
   ]
  }
 ],
 "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"
  },
  "vscode": {
   "interpreter": {
    "hash": "2024b47f9e0e00785bf7b410773834da4047a250e58841a8c9925163fbfa3efc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}