programmation_fonctionnelle.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b719be1f",
   "metadata": {},
   "source": [
    "# Programmation Fonctionnelle - Cours"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e390e046",
   "metadata": {},
   "source": [
    "## Ex 1 : tri par insersion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6877d87a",
   "metadata": {},
   "source": [
    "<u> programmation directe </u>: le tri s'effectue avec une comparaison en \"dur\" >"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dc75c68c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def insere(t, i, v):\n",
    "    \"\"\"insère v dans t[0..i[ supposé trié\"\"\"\n",
    "    j = i\n",
    "    while (j>0) and (t[j-1]>v):\n",
    "        t[j] = t[j-1]\n",
    "        j = j-1\n",
    "    t[j] = v\n",
    "    \n",
    "def tri_par_insersion(t):\n",
    "    \"\"\"trie le tableau t par ordre croissant\"\"\"\n",
    "    for i in range(1, len(t)):\n",
    "        insere(t, i, t[i])\n",
    "    return t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "193626f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, 5, 8, 8, 14]\n"
     ]
    }
   ],
   "source": [
    "tableau = [1, 8, 14, 5, 8, 5]\n",
    "print(tri_par_insersion(tableau))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "908f54c7",
   "metadata": {},
   "source": [
    "<u> programmation fonctionnelle </u>: le tri s'effectue avec une comparaison en inf(), qui peut donc être différente cela le besoin (un exemple classique est la définition d'une distance en foncçon de la dimension de l'espace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "821b5ffc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def insere(inf, t, i, v):\n",
    "    \"\"\"insère v dans t[0..i[ supposé trié\"\"\"\n",
    "    j = i\n",
    "    while (j>0) and not inf(t[j-1], v):\n",
    "        t[j] = t[j-1]\n",
    "        j = j-1\n",
    "    t[j] = v\n",
    "    \n",
    "def tri_par_insersion(inf, t):\n",
    "    \"\"\"trie le tableau t par ordre croissant\"\"\"\n",
    "    for i in range(1, len(t)):\n",
    "        insere(inf, t, i, t[i])\n",
    "    return t\n",
    "\n",
    "def inf(x, y):\n",
    "    return x <= y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d85c1697",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, 5, 8, 8, 14]\n"
     ]
    }
   ],
   "source": [
    "tableau = [1, 8, 14, 5, 8, 5]\n",
    "print(tri_par_insersion(inf, tableau))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58459903",
   "metadata": {},
   "source": [
    "## Ex 2 : tableau personne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4a34f455",
   "metadata": {},
   "outputs": [],
   "source": [
    "def insere(inf, t, i, v):\n",
    "    \"\"\"insère v dans t[0..i[ supposé trié\"\"\"\n",
    "    j = i\n",
    "    while (j>0) and not inf(t[j-1], v):\n",
    "        t[j] = t[j-1]\n",
    "        j = j-1\n",
    "    t[j] = v\n",
    "    \n",
    "def tri_par_insersion(inf, t):\n",
    "    \"\"\"trie le tableau t par ordre croissant\"\"\"\n",
    "    for i in range(1, len(t)):\n",
    "        insere(inf, t, i, t[i])\n",
    "    return t\n",
    "\n",
    "def inf_1(x, y):          # par nom\n",
    "    return x[0] <= y[0]\n",
    "\n",
    "def inf_2(x, y):          # pae prenom\n",
    "    return x[1] <= y[1]\n",
    "\n",
    "def inf_3(x, y):          # par age\n",
    "    return x[2] <= y[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7492779a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('bond', 'james', 32), ('dragel', 'eva', 25), ('ravel', 'carolie', 45), ('smith', 'john', 37)]\n",
      "[('ravel', 'carolie', 45), ('dragel', 'eva', 25), ('bond', 'james', 32), ('smith', 'john', 37)]\n",
      "[('dragel', 'eva', 25), ('bond', 'james', 32), ('smith', 'john', 37), ('ravel', 'carolie', 45)]\n"
     ]
    }
   ],
   "source": [
    "tableau = [(\"smith\", \"john\", 37), (\"ravel\", \"carolie\", 45), (\"bond\", \"james\", 32), (\"dragel\", \"eva\", 25)]\n",
    "print(tri_par_insersion(inf_1, tableau))\n",
    "print(tri_par_insersion(inf_2, tableau))\n",
    "print(tri_par_insersion(inf_3, tableau))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "237ce764",
   "metadata": {},
   "source": [
    "## Ex 3 : fonction come résultat (d'une fonction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "dabd4f16",
   "metadata": {},
   "outputs": [],
   "source": [
    "def derive(f):\n",
    "    h = 1e-7\n",
    "    return lambda x: (f(x+h)-f(x))/h\n",
    "\n",
    "d_sin = derive(sin)\n",
    "d_cos = derive(cos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "7924345e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sin'(0) = cos(0) = 1.00000\n",
      "cos'(0) = -sin(0) = -0.00000\n",
      "sin'(pi/2) = cos(pi/2) = -0.00000\n",
      "cos'(pi/2) = -sin(pi/2) = -1.00000\n"
     ]
    }
   ],
   "source": [
    "from math import sin, cos, pi\n",
    "\n",
    "print(f\"sin'(0) = cos(0) = {d_sin(0):.5f}\")\n",
    "print(f\"cos'(0) = -sin(0) = {d_cos(0):.5f}\")\n",
    "print(f\"sin'(pi/2) = cos(pi/2) = {d_sin(pi/2):.5f}\")\n",
    "print(f\"cos'(pi/2) = -sin(pi/2) = {d_cos(pi/2):.5f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1796796",
   "metadata": {},
   "source": [
    "# Codage - Fiche d'ex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf84843a",
   "metadata": {},
   "source": [
    "## Ex 36 : fonction trouve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f8c5dd95",
   "metadata": {},
   "outputs": [],
   "source": [
    "def trouve(p, t):\n",
    "    \"\"\"trouve le 1er elt de t telque p(x) est True\"\"\"\n",
    "    for x in t:\n",
    "        if p(x):\n",
    "            return x\n",
    "    return \"désolé, je n'ai rien trouvé\"\n",
    "\n",
    "def p(x: int):\n",
    "    \"\"\"regarde si x est pair\"\"\"\n",
    "    return not(x%2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fac0b96c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "désolé, je n'ai rien trouvé\n"
     ]
    }
   ],
   "source": [
    "t_1 = [1, 9, 5, 16, 13, 12, 15, 10]\n",
    "print(trouve(p, t_1))\n",
    "\n",
    "t_2 = [1, 9, 5, 13, 15]\n",
    "print(trouve(p, t_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d2001a8",
   "metadata": {},
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0a053bd",
   "metadata": {},
   "source": [
    "## Ex 37 : fonction applique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9674c3f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def applique_1(f, t):\n",
    "    \"\"\"applique une fonction f à chaque valeur du tableau t\"\"\"\n",
    "    r = []\n",
    "    for x in t:\n",
    "        r.append(f(x))\n",
    "    return r\n",
    "    \n",
    "def applique_2(f, t):\n",
    "    \"\"\"applique une fonction f à chaque valeur du tableau t\"\"\"\n",
    "    return [f(x) for x in t]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d0e6f95f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n",
      "[1, 3, 5, 7, 9]\n",
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    return 2*x+1\n",
    "\n",
    "\n",
    "t = [i for i in range(5)]\n",
    "\n",
    "print(applique_1(f, t))\n",
    "print(applique_2(f, t))\n",
    "print(list(map(f, t)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0543412",
   "metadata": {},
   "source": [
    "## Ex 39 : fonction double "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "08733594",
   "metadata": {},
   "outputs": [],
   "source": [
    "def double(f):\n",
    "    return lambda x: f(f(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6eb6ff7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    " print(double((lambda x: x/3))(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d1aeea1",
   "metadata": {},
   "source": [
    "## Ex 40 : fonction compose "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6c01090c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compose(f,g):\n",
    "    return lambda x: f(g(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "94b2a12e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "f = lambda x: x**2\n",
    "g = lambda x: 2*x+1\n",
    "print(compose(f,g)(2))\n",
    "print(compose(g,f)(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b783dbe",
   "metadata": {},
   "source": [
    "## Ex 42 : fonction repete_pause"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "d16338da",
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import sleep\n",
    "\n",
    "def repete_pause(f, n, t):\n",
    "    \"\"\"repete n appels f(0) jusqu'à f(n-1) avec des pauses intermédiaires de temps t\"\"\"\n",
    "    for i in range(n):\n",
    "        print(f(i), end = \" \")\n",
    "        sleep(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "f0648948",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "
     ]
    }
   ],
   "source": [
    "repete_pause((lambda i: chr(65+i)), 26, 1)"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}