IN102-02 Variables et Operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc": true
   },
   "source": [
    "<h1>Sommaire<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Types-et-variables\" data-toc-modified-id=\"Types-et-variables-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Types et variables</a></span><ul class=\"toc-item\"><li><span><a href=\"#Types-de-base\" data-toc-modified-id=\"Types-de-base-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Types de base</a></span><ul class=\"toc-item\"><li><span><a href=\"#Nombres-entiers\" data-toc-modified-id=\"Nombres-entiers-1.1.1\"><span class=\"toc-item-num\">1.1.1&nbsp;&nbsp;</span>Nombres entiers</a></span></li><li><span><a href=\"#Nombres-flottants\" data-toc-modified-id=\"Nombres-flottants-1.1.2\"><span class=\"toc-item-num\">1.1.2&nbsp;&nbsp;</span>Nombres flottants</a></span></li></ul></li><li><span><a href=\"#Déclaration-de-variables\" data-toc-modified-id=\"Déclaration-de-variables-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Déclaration de variables</a></span></li><li><span><a href=\"#Afficher-une-variable-avec-printf\" data-toc-modified-id=\"Afficher-une-variable-avec-printf-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Afficher une variable avec <code>printf</code></a></span></li><li><span><a href=\"#Les-flottants\" data-toc-modified-id=\"Les-flottants-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Les flottants</a></span></li><li><span><a href=\"#Exercice:-Précision\" data-toc-modified-id=\"Exercice:-Précision-1.5\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>Exercice: Précision</a></span></li><li><span><a href=\"#Portée-des-variables\" data-toc-modified-id=\"Portée-des-variables-1.6\"><span class=\"toc-item-num\">1.6&nbsp;&nbsp;</span>Portée des variables</a></span></li></ul></li><li><span><a href=\"#Expressions-et-instructions\" data-toc-modified-id=\"Expressions-et-instructions-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Expressions et instructions</a></span><ul class=\"toc-item\"><li><span><a href=\"#Expressions-de-base\" data-toc-modified-id=\"Expressions-de-base-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Expressions de base</a></span></li><li><span><a href=\"#Expressions-arithmétiques\" data-toc-modified-id=\"Expressions-arithmétiques-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Expressions arithmétiques</a></span></li><li><span><a href=\"#Exercice:-Divison-entière\" data-toc-modified-id=\"Exercice:-Divison-entière-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Exercice: Divison entière</a></span></li><li><span><a href=\"#Affectation-et-test-d'égalité\" data-toc-modified-id=\"Affectation-et-test-d'égalité-2.4\"><span class=\"toc-item-num\">2.4&nbsp;&nbsp;</span>Affectation et test d'égalité</a></span></li><li><span><a href=\"#Opérations-logiques\" data-toc-modified-id=\"Opérations-logiques-2.5\"><span class=\"toc-item-num\">2.5&nbsp;&nbsp;</span>Opérations logiques</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention:** Pour activer le langage C, executer le code suivant avec Shift+Entrée où avec le bouton \"Run\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "!pip install git+git://github.com/frehseg/gcc4jupyter\n",
    "%load_ext gcc_plugin\n",
    "%load_ext add_cpp_magic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Types et variables\n",
    "\n",
    "Les informations que l’on souhaite traiter peuvent être de natures variées : entiers naturels, rationnels, valeurs de vérité (vrai / faux), lettres, texte ...\n",
    "\n",
    "Les langages de programmation fournissent des types de données variés à cet effet.\n",
    "Le type est nécessaire pour :\n",
    "- savoir combien de place (octets) réserver en mémoire\n",
    "- appeler la bonne version des fonctions et opérateurs\n",
    "     `+`,`-`,`/`, etc. qui sont différent au niveau materiel si entiers ou flottants\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Types de base \n",
    "En C, il y a 3 types de base pour représenter des nombres: \n",
    "- les entiers (`int`),\n",
    "- les réels (`float` et `double`),\n",
    "- les caractères (`char`) - pour l'ordi ce n'est qu'un nombre.\n",
    "\n",
    "On appelle __booléen__ le type des valeurs de vérité (≪ vrai ≫ et ≪ faux ≫). C ne fournit pas de vrais booléens. En C, ce sont des entiers avec pour convention 0 ≡ ≪ faux ≫ et (tout sauf 0) ≡ ≪ vrai ≫.\n",
    "\n",
    "### Nombres entiers\n",
    "Les types de nombres entiers existent en version avec signe (`signed`) ou sans signe (`unsigned`):\n",
    "\n",
    "- `unsigned char` : caractère sur 1 octet, valeurs 0...255\n",
    "- `signed char` : caractère sur 1 octet, valeurs -128...127\n",
    "- `char` : peut être signed ou unsigned (voir limit.h)\n",
    "- `int` : entiers sur au moins 2 octets, mais très souvont 4 octets = 32 bit <br>\n",
    "    valeurs de $-2^{31}$  à $2^{31}-1$ (1 bit pour le signe) <br>\n",
    "    = -2,147,483,648 à 2,147,483,647\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Nombres flottants\n",
    "- `float` : flottants de basse précision, sur 4 octets\n",
    "- `double` : flottants de haute précision, sur 8 octets\n",
    "- ... d'autres ...\n",
    "- pas de boolean, utiliser `int` : <br>\n",
    "    faux = `0` <br>\n",
    "    vrai = toute autre valeur (1,-1,...) \n",
    "\n",
    "La taille en octets peut varier selon la machine et le compilateur; si besoin consulter `limit.h` (cours ultérieur)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Déclaration de variables\n",
    "\n",
    "Un programme manipule des données stockées en mémoire. Il faut donc pouvoir manipuler des ≪ réceptacles ≫ d’information : des variables.\n",
    "En C, on déclare une variable en donnant son type suivi de son nom :\n",
    "\n",
    "```int compteur; ```\n",
    "\n",
    "On peut initialiser une variable directement au moment de sa déclaration en lui affectant une valeur par la construction `=` :\n",
    "\n",
    "```int compteur = 0; ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Afficher une variable avec `printf`\n",
    "\n",
    "Afficher une variable (entier):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   int i = 23;\n",
    "   printf(\"hello %d bye bye\",i);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`%d` est remplaçé par la variable après le virgule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Afficher plusieurs variables (entier):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   int i = 23;\n",
    "   int j = 17;\n",
    "   int k = 3;\n",
    "   printf(\"d'abord %d, après %d, ensuite %d\",i,j,k);\n",
    "   return 0; \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Les `%d` sont remplaçés dans l'ordre d'apparition par les variables après le virgule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Afficher sur plusieurs lignes avec `\\n`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   int i = 23;\n",
    "   int j = 17;\n",
    "   int k = 3;\n",
    "   printf(\"d'abord %d,\\naprès %d,\\nensuite %d\",i,j,k);\n",
    "   return 0; \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Codes utiles:\n",
    "- `%c`: caractère (ASCII)\n",
    "- `%d`: entier\n",
    "- `%f`: flottant (float ou double)\n",
    "- `%g`: flottant en format compact\n",
    "- ... d'autres ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   double x = 12345;\n",
    "   printf(\"%f\\n\",x);\n",
    "   printf(\"%g\\n\",x);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Précision: \n",
    "- `%.3f` : avec 3 décimales \n",
    "- `%.3g` : avec 3 chiffres significatives "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   double x = 12345;\n",
    "   printf(\"%.3f\\n\",x);\n",
    "   printf(\"%.3g\\n\",x);\n",
    "   printf(\"%.4g\\n\",x);\n",
    "   printf(\"%.5g\\n\",x);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Alerte Bug:** Ce que donne le programme suivant?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   double x = 1.23;\n",
    "   printf(\"%d\",x);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les octets de `x` sont traités comme si c'était un entier -- puisque le codage est complètement différent ça donne n'importe quoi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Les flottants\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/a/a9/IEEE_754_Double_Floating_Point_Format.svg/1236px-IEEE_754_Double_Floating_Point_Format.svg.png\" alt=\"Double Precision\" width = \"75%\"/>\n",
    "\n",
    "<img src=\"https://wikimedia.org/api/rest_v1/media/math/render/svg/61345d47f069d645947b9c0ab676c75551f1b188\" alt=\"Double Precision\" width = \"50%\"/>\n",
    "\n",
    "zéro : fraction et exposant sont zéro <br>\n",
    "précision : $2^{−52} ≈ 2.22 × 10^{−16}$   (*machine epsilon*) <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice: Précision\n",
    "Pour tester la précision, affichez les valeurs \n",
    "- $1$\n",
    "- $1+ 1 × 10^{−16}$\n",
    "- $1+ 2 × 10^{−16}$\n",
    "\n",
    "avec précision maximale en utilisant le format `%.17g`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "    /* ... a compléter ... */\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "    printf(\"%.17g\\n\", 1.0 );\n",
    "    printf(\"%.17g\\n\", 1.0 + 1e-16 );\n",
    "    printf(\"%.17g\\n\", 1.0 + 2e-16 );\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Portée des variables\n",
    "\n",
    "Une variable dans un bloc `{`... `}` est reconnue seulement dans ce bloc:\n",
    "\n",
    "``{ \n",
    "   int i = 123;\n",
    "}\n",
    "``\n",
    "\n",
    "On l'appele une variable __locale__.\n",
    "\n",
    "Les variables qui ne sont dans aucun bloc sont des variables __globales__, disponibles partout dans le programme. Les variables globales entraînent facilement des bugs, donc on __préfère des variables locales__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Elle est distinct des autres variables en dehors du bloc, même des celles qui portent le même nom.\n",
    "\n",
    "``\n",
    "int i = -7;\n",
    "{ \n",
    "   int i = 123;\n",
    "   printf(\"%d \",i);\n",
    "}\n",
    "printf(\"%d \",i);\n",
    "``\n",
    "\n",
    "affiche: `123 -7`\n",
    "\n",
    "La variable est 'détruite' à la fin du bloc : la place réservée pour la mémoire est libérée et peut désormais être utilisée pour d'autres variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Les blocs peuvent être imbriqués :\n",
    "\n",
    "``\n",
    "int i = 4;\n",
    "{ \n",
    "    int i = -7;\n",
    "    { \n",
    "       int i = 123;\n",
    "       printf(\"%d \",i);\n",
    "    }\n",
    "    printf(\"%d \",i);\n",
    "}\n",
    "printf(\"%d \",i);\n",
    "``\n",
    "\n",
    "affiche: `123 -7 4`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Expressions et instructions\n",
    "En simplifiant, on différencie 2 types de constructions de C :\n",
    "— Les expressions, qui ≪ ont une valeur ≫ (elles ≪ valent ≫) et n’ont pas d’effet.\n",
    "— Les instructions, qui ≪ ont un effet ≫ (elles ≪ font ≫) sans forcément valoir quelque chose.\n",
    "La différence réelle entre instruction et expression est plus complexe et plus floue en C.\n",
    "\n",
    "## Expressions de base\n",
    "\n",
    "\n",
    "Expressions de base :\n",
    "-Variables : toute variable d ́eclar ́ee et de port ́ee accessible.\n",
    "- Entiers : 344578 \n",
    "- Caractères : ’U’, ’\\n’ (**notez les guillemets simples**)\n",
    "- Flottants : −4.6, 5e-12\n",
    "- Chaînes : ”plop” (**guillemets doubles**)\n",
    "  ”\\\\tGlop\\\\n”\n",
    "\n",
    "## Expressions arithmétiques\n",
    "\n",
    "- comme d'habitude : `x + y`, `x - y`, `x * y`\n",
    "- __attention à la division__ : `x / y`\n",
    "    - division entière si `x,y` sont `int`\n",
    "    - division flottante si un des deux `float` ou `double`\n",
    "- modulo (reste de la division entière): `x % y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   int x = 7;\n",
    "   int y = 3;\n",
    "   printf(\"%d\", x / y );\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   double x = 7;\n",
    "   double y = 3;\n",
    "   printf(\"%f\", x / y );\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice: Divison entière\n",
    "\n",
    "Affichez le résultat du calcul `(x+y)/z` avec x=1, y=2, z=5\n",
    "- d'abord tous `int`,\n",
    "- ensuite un seul en `double`.\n",
    "Est-ce que ça fait une différence lequel est `double`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   /** A compléter **/\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Affectation et test d'égalité\n",
    "\n",
    "- l'affectation `x = y` donne comme valeur de retour la nouvelle valeur de `x`\n",
    "- ça permet d'écrire par exemple `x = y = z = 3` (déconseillé)\n",
    "\n",
    "__attention__: facile à confondre avec le test d'égalité `x == y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   int x = 2;\n",
    "   int y = 3;\n",
    "   printf(\"%d\\n\", x==y );\n",
    "   printf(\"%d\\n\", x );\n",
    "   printf(\"%d\\n\", x=y );\n",
    "   printf(\"%d\\n\", x );\n",
    "} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour tester si `x` et `y` sont différentes, on peut utiliser `x != y`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Opérations logiques\n",
    "- et logique : `x && y`\n",
    "- ou logique : `x || y`\n",
    "- négation : `!x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   int x = 3; // vrai, car pas 0\n",
    "   int y = 0; // faux, car 0\n",
    "   printf(\"%d\\n\", x && y);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   int x = 3; // vrai, car pas 0\n",
    "   int y = 1; // vrai, car pas 0\n",
    "   printf(\"%d\\n\", x && y);\n",
    "   printf(\"%d\\n\", !0 );\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__attention__:\n",
    "- et par bit : `x & y`\n",
    "- ou par bit : `x | y`\n",
    "- négation par bit : `~x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main() {\n",
    "   int x = 2; // vrai, car pas 0\n",
    "   int y = 1; // vrai, car pas 0\n",
    "   printf(\"%d\\n\", x && y);\n",
    "   printf(\"%d\\n\", x & y);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`2` en binaire = `10`, `1` en binaire = `01` <br>\n",
    "`2 && 1` en binaire = `00`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  },
  "rise": {
   "enable_chalkboard": true,
   "theme": "simple",
   "transition": "none"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Sommaire",
   "title_sidebar": "Sommaire",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "261px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}