{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programmare in Python\n",
    "\n",
    "## Esercizi: Numpy\n",
    "\n",
    "In questi esercizi array si riferisce a numpy.array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1 - Create un array di 50 elementi, ciascuno uguale a $e$, la base dei logaritmi naturali. Verificate che l'array contenga esattamente 50 elementi.__ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2 - Create un array `angles` che contenga tutti gli angoli fra 0 e 360 gradi, in incrementi di un grado. Quanti sono gli elementi? Calcolate il seno e il coseno di tutti gli elementi di `angles`.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__3 - Create un array di nove numeri equidistanti, il cui primo e ultimo elemento siano rispettivamente 0 e 23, e assegnarlo alla variabile r. Calcolate il quadrato di ciascun elemento di r. Calcolate il doppio di ogni elemento di r usando 1) moltiplicazione 2) somma.__ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__4 - Create un array da 13 a 19, 19 escluso, in incrementi di 0.2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__5 - Create un array da 13 a 19, 19 incluso, in incrementi di 0.2. Calcolate l'esponenziale din ciascun elemento dell'array.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__6 - Calcolate la coordinata y di 200 punti della parabola y = 0.5\\*x\\*\\*2 -x +2  per valori di x equidistanziati e compresi fra -2 e 2, estremi inclusi.__  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__7 - Create un array 5 × 5 che sia zero dappertutto ad eccezione della diagonale dove gli elementi sono [1,2,3,4,5]. Determinare size e shape dell'array.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__8 - Create un array 8 × 8 con righe alternate di uno e zero.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__9 - Create un array 7 × 7 con colonne alternate di uno e zero.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__10 - Dato l'array k = np.arange(2, 100, 3), aggiungete 100 a tutti i multipli di 7.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__11 - Costruite la matrice:__\n",
    "$$A = \\begin{bmatrix} -2 & 3\\\\ 4 & 5 \\end{bmatrix}$$\n",
    "__Calcolate il determinante e, se possibile, l'inversa. Se l'inversa esiste controllate il vostro risultato calcolando il prodotto della matrice $A$ e della sua inversa.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__12 - Risolvete il sistema di equazioni lineari:__\n",
    "$$ 3 a + b - c = 1$$\n",
    "$$ a - b + 2 c = 3$$\n",
    "$$ -2 a + 3 b = 2$$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__13 - Scrivete una funzione che calcoli la distanza euclidea fra due punti in uno spazio ad N dimensioni, qualunque sia N.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__14 - La posizione, al tempo t, di una palla che sia stata lasciata cadere con velocità iniziale nulla da una altezza $h_0$ è data da:\n",
    "$$y = h_0 − \\frac{1}{2}\\, g\\, t^2$$ \n",
    "dove $g = 9.81 m/s^2$. Supponiamo $h0 = 10\\, m$. Trovate la sequenza di tempi a cui la palla completa ciascun intervallo di lunghezza mezzo metro, supponendo che la palla sia lasciata cadere a t=0. <br>\n",
    "Suggerimento: create un array NumPy per y che va da 10 a 0 in incrementi di −0.5 usando la funzione arange.<br>\n",
    "Salvate il vostro codice in una funzione. Una volta creati gli array y e t eseguite il comando `list(zip(t, y))`. Interpretate il risultato.__<BR>\n",
    "(D.J.Pine - Introduction to Python for Science and Engineering)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__15 - Ricordando che la velocità media su un intervallo $\\Delta t$ è definita come $\\bar{v} = \\Delta y/\\Delta t$, trovate la velocità media per ciascun intervallo del problema precedente utilizzando gli array NumPy.<br>\n",
    "Suggerimento: cosa sono gli array y[1:20] e y[0:19]?.<br> \n",
    "Bonus 1: riuscite a immaginare un modo più elegante di rappresentare y[1:20]-y[0:19] che non fa riferimento esplicito al numero di elementi dell'array y, cioè che funzionerebbe per un array di lunghezza arbitraria?<br>\n",
    "Bonus 2: Calcolate l'accelerazione in funzione del tempo usando la formula $\\bar{a} = \\Delta v/\\Delta t$. Esprimete i tempi a cui le velocità sono calcolate prendendo il punto medio degli intervalli dell'array dei tempi usato in precedenza. Spiegate il risultato ottenuto per le accelerazioni.__<BR>\n",
    "(D.J.Pine - Introduction to Python for Science and Engineering)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__16 - Costruite una funzione `Cull(A,n)` in cui A è un array bidimensionale di numeri interi e n è un intero positivo. La funzione `Cull` deve sostituire tutti gli interi divisibili per `n` in A con 0 e restituire il risultato. Testate la funzione con la matrice:__\n",
    "```\n",
    "D = np.array(\n",
    "[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n",
    " [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24],\n",
    " [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36],\n",
    " [4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48],\n",
    " [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60],\n",
    " [6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72],\n",
    " [7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84],\n",
    " [8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96],\n",
    " [9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99, 108],\n",
    " [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120],\n",
    " [11, 22, 33, 44, 55, 66, 77, 88, 99, 110, 121, 132],\n",
    " [12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144]]\n",
    ")\n",
    "```\n",
    "__e  `n` = 3.__ \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__17 - Data la matrice:__\n",
    "$$\n",
    "R = \\left( \\begin{matrix}\n",
    "1 & 0 & 1 & -1 \\\\\n",
    "1 & 2 & 2 & 0\\\\ \n",
    "0 & 1 & -1 & 1\\\\\n",
    "2 & 0 & 1 & -1\\\\\n",
    "\\end{matrix} \\right)\n",
    "$$\n",
    "\n",
    "__Verificate che la matrice è invertibile. Calcolate la matrice inversa `Rinv` e usate `Rinv` per risolvere\n",
    "i sistemi di equazioni lineari R\\*X=B1 e R\\*X=B2 con B1 = [1,1,2,1] e B2 = [10,0,0,1]. X è il vettore delle incognite.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__18 - Costruite una funzione column(A,n), dove A è un array a due dimensioni e n è un intero $\\ge$ 0,\n",
    "che restituisca la somma degli elementi della colonna di indice n della matrice A, se A ha almeno n+1 colonne, altrimenti restituisca zero.__<BR>\n",
    "__Verificate la vostra funzione sulla matrice:__\n",
    "$$\n",
    "R = \\left( \\begin{matrix}\n",
    "1 & 1 & 0 \\\\\n",
    "1 & 2 & 2 \\\\ \n",
    "0 & 1 & -1 \\\\\n",
    "\\end{matrix} \\right)\n",
    "$$\n",
    "\n",
    "__per n = 1 e n = 4.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__19 - Risolvere il sistema di equazioni:__\n",
    "$$x+2y +3z+4t=2$$ \n",
    "$$-x+3y-6z+8t=0$$\n",
    "$$x+ y-z +t=-1$$\n",
    "$$2y-z-t=1$$\n",
    "__Verificare che la soluzione trovata soddisfa le equazioni di partenza.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__20 - Scrivere una funzione che prenda come input due vettori, v1 e v2, di dimensione arbitraria, e restituisca la scomposizione di v1 in due vettori w1 e w2, il primo parallelo a v2 e il secondo ortogonale a v2.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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": {},
   "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
}