IN102-06 Fonctions (suite) - Entrees - Struct.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    },
    "toc": true
   },
   "source": [
    "<h1>Sommaire<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Fonctions-(suite)\" data-toc-modified-id=\"Fonctions-(suite)-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Fonctions (suite)</a></span><ul class=\"toc-item\"><li><span><a href=\"#Passage-par-valeur\" data-toc-modified-id=\"Passage-par-valeur-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Passage par valeur</a></span><ul class=\"toc-item\"><li><span><a href=\"#Avantage-de-passage-à-valeur\" data-toc-modified-id=\"Avantage-de-passage-à-valeur-1.1.1\"><span class=\"toc-item-num\">1.1.1&nbsp;&nbsp;</span>Avantage de passage à valeur</a></span></li><li><span><a href=\"#Inconvénient-de-passage-à-valeur\" data-toc-modified-id=\"Inconvénient-de-passage-à-valeur-1.1.2\"><span class=\"toc-item-num\">1.1.2&nbsp;&nbsp;</span>Inconvénient de passage à valeur</a></span></li></ul></li><li><span><a href=\"#Passage-par-adresse\" data-toc-modified-id=\"Passage-par-adresse-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Passage par adresse</a></span><ul class=\"toc-item\"><li><span><a href=\"#Avantage-de-passage-par-adresse\" data-toc-modified-id=\"Avantage-de-passage-par-adresse-1.2.1\"><span class=\"toc-item-num\">1.2.1&nbsp;&nbsp;</span>Avantage de passage par adresse</a></span></li><li><span><a href=\"#Inconvénient-de-passage-par-adresse\" data-toc-modified-id=\"Inconvénient-de-passage-par-adresse-1.2.2\"><span class=\"toc-item-num\">1.2.2&nbsp;&nbsp;</span>Inconvénient de passage par adresse</a></span></li><li><span><a href=\"#Exemple:-Incrémenter\" data-toc-modified-id=\"Exemple:-Incrémenter-1.2.3\"><span class=\"toc-item-num\">1.2.3&nbsp;&nbsp;</span>Exemple: Incrémenter</a></span></li><li><span><a href=\"#Exemple:-Echanger-deux-valeurs-(swap)\" data-toc-modified-id=\"Exemple:-Echanger-deux-valeurs-(swap)-1.2.4\"><span class=\"toc-item-num\">1.2.4&nbsp;&nbsp;</span>Exemple: Echanger deux valeurs (swap)</a></span></li></ul></li><li><span><a href=\"#Prototype-de-fonction\" data-toc-modified-id=\"Prototype-de-fonction-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Prototype de fonction</a></span></li></ul></li><li><span><a href=\"#Lire-des-Entrées-au-Clavier\" data-toc-modified-id=\"Lire-des-Entrées-au-Clavier-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Lire des Entrées au Clavier</a></span><ul class=\"toc-item\"><li><span><a href=\"#Format-de-scanf\" data-toc-modified-id=\"Format-de-scanf-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Format de scanf</a></span></li></ul></li><li><span><a href=\"#Boucles-(suite)\" data-toc-modified-id=\"Boucles-(suite)-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Boucles (suite)</a></span><ul class=\"toc-item\"><li><span><a href=\"#Boucle-do-while\" data-toc-modified-id=\"Boucle-do-while-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Boucle do-while</a></span></li></ul></li><li><span><a href=\"#Structures\" data-toc-modified-id=\"Structures-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Structures</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exemple:-Cercle\" data-toc-modified-id=\"Exemple:-Cercle-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Exemple: Cercle</a></span></li><li><span><a href=\"#Pointeurs-vers-structures\" data-toc-modified-id=\"Pointeurs-vers-structures-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Pointeurs vers structures</a></span></li><li><span><a href=\"#Exercice:-Modifier-le-radius\" data-toc-modified-id=\"Exercice:-Modifier-le-radius-4.3\"><span class=\"toc-item-num\">4.3&nbsp;&nbsp;</span>Exercice: Modifier le radius</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": [
    "!pip install git+git://github.com/frehseg/gcc4jupyter\n",
    "%load_ext gcc_plugin\n",
    "# Marche pas sur Google Colab: %load_ext add_cpp_magic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Fonctions (suite)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Passage par valeur\n",
    "\n",
    "Les arguments sont des __variables__:\n",
    "\n",
    "``\n",
    "int carre_par_valeur(int z) {\n",
    "   return z*z;\n",
    "}``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "``int main() {\n",
    "   int x = 3;\n",
    "   x = carre_par_valeur(x);\n",
    "   printf(\"%d\",x);\n",
    "}\n",
    "``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "1. Je fais une __copie__ de `x` dans `z`.\n",
    "2. Je fais un calcul avec.\n",
    "3. Je copie le résultat du calcul dans la __valeur de retour__ (registre)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Avantage de passage à valeur\n",
    "- facile à écrire\n",
    "\n",
    "### Inconvénient de passage à valeur\n",
    "- copies des valeurs (`x` vers `z`) --> lent (ça dépend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Passage par adresse\n",
    "\n",
    "L'argument est un __pointeur__:\n",
    "\n",
    "``\n",
    "void carre_par_adresse(int* px) {\n",
    "    (*px) = (*px) * (*px); // rappel: (*px) identique à x\n",
    "}``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "``int main() {\n",
    "   int x = 3;\n",
    "   carre_par_adresse(&x);\n",
    "   printf(\"%d\",x);\n",
    "}\n",
    "``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "1. Je fais le calcul directement avec `x`.\n",
    "2. Je manipule `x` via un pointeur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Avantage de passage par adresse\n",
    "- pas de copie --> rapide\n",
    "- on peut manipuler plusieurs valeurs!\n",
    "\n",
    "### Inconvénient de passage par adresse\n",
    "- plus difficile à écire\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exemple: Incrémenter\n",
    "\n",
    "On essaie d'écrire une fonction qui incrémente la valeur de son argument par 1. Observez ce que fait la version avec passage par valeur:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "void incrementer(int x) {\n",
    "    x = x + 1;\n",
    "}\n",
    "int main() {\n",
    "   int x = 7;\n",
    "   incrementer(x);\n",
    "   printf(\"%d\",x);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x` dans `main` ne change pas. Il est impossible de modifier `x` avec une fonction avec passage par valeur, sans passer par la valeur de retour."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici une version avec passage par adresse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "void incrementer(int* px) {\n",
    "    *px = *px + 1;\n",
    "}\n",
    "int main() {\n",
    "   int x = 7;\n",
    "   incrementer(&x);\n",
    "   printf(\"%d\",x);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fois, la variable `x` de `main` change de valeur. Avec passage par adresse, la fonction a accès à la variable `x` du `main`, en passant par le pointeur `px`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exemple: Echanger deux valeurs (swap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "void swap(int x, int y) {\n",
    "   int temp = x;\n",
    "   x = y;\n",
    "   y = temp;\n",
    "}\n",
    "int main() {\n",
    "   int x = 7; int y = 3; // <@>\n",
    "   swap(x,y);\n",
    "   printf(\"%d,%d\",x,y);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "void swap(int* px, int* py) {\n",
    "   int temp = *px;\n",
    "   *px = *py;\n",
    "   *py = temp;\n",
    "}\n",
    "int main() {\n",
    "   int x = 7; int y = 3; // <@>\n",
    "   swap(&x,&y);\n",
    "   printf(\"%d,%d\",x,y);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prototype de fonction\n",
    "\n",
    "Le prototype, ou __déclaration__, d'une fonction est \n",
    "\n",
    "   valeur-de-retour `nom_de_fonction(` ...arguments...`);`\n",
    "\n",
    "Exemples:\n",
    "\n",
    "`double Fahrenheit2Celsius(double x);`\n",
    "\n",
    "`void afficher_resultat(double x, double y);`\n",
    "\n",
    "`void swap(int* px, int* py);`\n",
    "\n",
    "Pour utiliser la fonction dans __autre fichier__, il suffit de connaître son prototype.\n",
    "\n",
    "Rappel: la __définition__ d'une fonction inclut aussi son corps (les instructios entre accolades):\n",
    "\n",
    "\n",
    "   valeur-de-retour `nom_de_fonction(` ...arguments...`) {`\n",
    "        ...instructions...\n",
    "    `};`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lire des Entrées au Clavier\n",
    "\n",
    "Pour afficher une variable : \n",
    "\n",
    "    `printf(\"message: %d\",x)`\n",
    "\n",
    "Pour lire une valeur au clavier : \n",
    "\n",
    "    `scanf(\"%d\", &x)`\n",
    "\n",
    "__Attention__: Pas de message dans `scanf`! Donner seulement le format (`%d,%f`,...)\n",
    "    \n",
    "`&x`: l'adresse de `x`(pourquoi on utilise l'adresse?)\n",
    "\n",
    "valeur de retour : nombre de valeurs lus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour afficher deux valeurs : \n",
    "\n",
    "    `printf(\"message: %d,%d\",x,y)`\n",
    "\n",
    "Pour lire deux valeurs au clavier : \n",
    "\n",
    "    `scanf(\"%d,%d\", &x, &y)`\n",
    "\n",
    "valeur de retour : nombre de valeurs lus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```\n",
    "#include <stdio.h>\n",
    "int main() {\n",
    "    int x,y;\n",
    "    printf(\"Entrer deux valeurs: \");\n",
    "    int n = scanf(\"%d,%d\",&x,&y);\n",
    "    printf(\"x=%d,y=%d,n=%d\\n\",x,y,n);\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "$ ./a.out\n",
    "Entrer deux valeurs: 3,4\n",
    "x=3,y=4,n=2\n",
    "$ ./a.out \n",
    "Entrer deux valeurs: 3 4\n",
    "x=3,y=1759981600,n=1\n",
    "$ ./a.out\n",
    "Entrer deux valeurs: 3 a\n",
    "x=3,y=1604196336,n=1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Format de scanf\n",
    "\n",
    "Utiliser les codes suivants selon le type de variable:\n",
    "- `%d`: `int` (avec signe)\n",
    "- `%u`: `unsigned int` (sans signe)\n",
    "- `%f`: `float` (mais pas `double`)\n",
    "- `%lf`: `double` (mais pas `float`)\n",
    "\n",
    "**Attention:** \n",
    "- `printf(\"%f\",x);` marche si `x` est `float` et aussi si `x` est `double`.\n",
    "- `scanf(\"%f\",&x);` marche seulement si `x` est `float`!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Boucles (suite)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boucle do-while\n",
    "\n",
    "La boucle __while__ est parfois pas très élégante :\n",
    "\n",
    "```\n",
    "#include <stdio.h>\n",
    "int main() {\n",
    "    int reponse;\n",
    "    printf(\"Entrez 4 pour quitter: \");\n",
    "    scanf(\"%d\",&reponse);\n",
    "    while (reponse!=4) {\n",
    "        scanf(\"%d\",&reponse);\n",
    "    } \n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`scanf`est écrit deux fois : deux fois plus de chance d'un bug"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "variante : boucle `do`-`while` execute son corps au moins une fois"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "#include <stdio.h>\n",
    "int main() {\n",
    "    int reponse;\n",
    "    printf(\"Entrez 4 pour quitter: \");\n",
    "    do {\n",
    "        scanf(\"%d\",&reponse);\n",
    "    } while (reponse!=4) \n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "raw_mimetype": "text/markdown"
   },
   "source": [
    "<script>\n",
    "    console.log(\"Hello. You'll see this printed in your browser's DevTools / Console. Feel free to delete this line.\");\n",
    "    document.querySelector('head').innerHTML += '<style>.slides { zoom: 1.0 !important; }</style>';\n",
    "</script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Structures\n",
    "Les structures répondent au besoin d’aggréger des données de types différents.\n",
    "Une structure est un groupement de données par champs nommés.\n",
    "Déclaration d’un type structure :\n",
    "\n",
    "```\n",
    "struct nom-type { \n",
    "    nom-champ1 type-champ1 ;\n",
    "    ... ; \n",
    "    nom-champn type-champn ;\n",
    "} ;\n",
    "```\n",
    "\n",
    "Déclaration d’une variable de type `struct` : \n",
    "\n",
    "```\n",
    "struct nom-type nom-variable \n",
    "```\n",
    "\n",
    "Comme pour les tableaux, il est possible d’initialiser directement les valeurs des champs d’une variable de type structure *lors de sa déclaration*, mais impossible d’affecter d’un seul coup une telle variable.\n",
    "L’accès à un champ de la structure se fait par notation pointée : \n",
    "\n",
    "```    \n",
    "nom-variable.nom-champ\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemple: Cercle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "\n",
    "struct circle {\n",
    "    int x ;\n",
    "    int y ; \n",
    "    unsigned int radius ;\n",
    "};\n",
    "\n",
    "int main() {\n",
    "    struct circle c = { 100,50,7 };\n",
    "    printf(\"Un cercle à (%d,%d) avec radius %d.\\n\",\n",
    "          c.x,c.y,c.radius);\n",
    "    struct circle d = c;\n",
    "    printf(\"Une copie du cercle à (%d,%d) avec radius %d.\\n\",\n",
    "          d.x,d.y,d.radius);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention:** Pour définir un cercle après sa première\n",
    "déclaration, on ne peut pas utiliser la notation\n",
    "`{ valeur, valeur, ... }`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "\n",
    "struct circle {\n",
    "    int x ;\n",
    "    int y ; \n",
    "    unsigned int radius ;\n",
    "};\n",
    "\n",
    "int main() {\n",
    "    struct circle c;\n",
    "    c = { 100,50,7 }; // ne marche pas, car est trop tard\n",
    "    printf(\"Un cercle à (%d,%d) avec radius %d.\\n\",\n",
    "          c.x,c.y,c.radius);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fois la structure est crée, il ne peut que modifier les champs un à la fois:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "\n",
    "struct circle {\n",
    "    int x ;\n",
    "    int y ; \n",
    "    unsigned int radius ;\n",
    "};\n",
    "\n",
    "int main() {\n",
    "    struct circle c;\n",
    "    c.x = 100;\n",
    "    c.y = 50;\n",
    "    c.radius = 7;\n",
    "    printf(\"Un cercle à (%d,%d) avec radius %d.\\n\",\n",
    "          c.x,c.y,c.radius);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pointeurs vers structures\n",
    "Si `p` est un pointeur vers une structure avec un champ `x`, `p.x` ne marche pas. Il faut utiliser **`p->x`**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par exemple, on crée une fonction pour déplacer un cercle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "\n",
    "struct circle {\n",
    "    int x ;\n",
    "    int y ; \n",
    "    unsigned int radius ;\n",
    "};\n",
    "\n",
    "void deplacer(struct circle* p, int dx, int dy) {\n",
    "    p->x = p->x+dx;\n",
    "    p->y = p->y+dy;\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    struct circle c = { 100,50,7 };\n",
    "    deplacer(&c,3,4);\n",
    "    printf(\"Un cercle à (%d,%d) avec radius %d.\\n\",\n",
    "          c.x,c.y,c.radius);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice: Modifier le radius\n",
    "Ajoutez une fonction `elargir(struct circle* p, int dr)` pour augmenter le radius d'un cercle par une quantité `dr`. Testez avec `dr=4`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%c\n",
    "#include <stdio.h>\n",
    "struct circle {\n",
    "    int x ;\n",
    "    int y ; \n",
    "    unsigned int radius ;\n",
    "};\n",
    "\n",
    "int main() {\n",
    "    struct circle c = { 100,50,7 };\n",
    "    \n",
    "    /** A vous de jouer */\n",
    "    \n",
    "    printf(\"Un cercle à (%d,%d) avec radius %d.\\n\",\n",
    "          c.x,c.y,c.radius);\n",
    "}"
   ]
  }
 ],
 "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
}