1-ClassRoom/20-numbers-headaches.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numbers headaches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "C++ benefits for scientific computing:\n",
    "* performance and precision is the primary priority\n",
    "* compatibility with C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Drawbacks:\n",
    "* portability is not the primary priority\n",
    "* some C inherited features, such as implicit conversions, may lead to tricky numerical errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Uninitialized variables\n",
    "\n",
    "First thing to be very careful about: if a basic variable is defined without any initial value, there is no guarantee that its value is set to 0. The C designers probably thought it was a waste of precious runtime..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Recommendation : **always give an initial value to your variables**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If by mistake you use an uninitialized variable, no doubt that the compiler will give you a warning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Recommendation : **compiler's warnings should be taken with the utmost seriousness**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Unportable numeric types\n",
    "\n",
    "The size of numeric variable types in C++ depends on the implementation. This may impede the portability of the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For example, the following rules are imposed on integer types by the C++ standards:\n",
    "* `short` : a width of at least 16 bits.\n",
    "* `int`   : a width of at least 16 bits.\n",
    "* `long`  : a width of at least 32 bits.\n",
    "* `sizeof(short)` <= `sizeof(int)` <= `sizeof(long)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The rules on floating point types are not strict either:\n",
    "* `sizeof(float)` <= `sizeof(double)` <= `sizeof(long double)`\n",
    "* `float`  : typically 32 bits *(IEEE 754, 6-9 significant digits, typically 7)*.\n",
    "* `double` : typically 64 bits *(IEEE 754, 15-18 significant digits, typically 16)*.\n",
    "* `long double` : 80 to 128 bits *(18-36 significant digits)*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For a given platform, the standard class `numeric_limits` can help to check the sizes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#include <iostream>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "#include <limits>\n",
    "\n",
    "std::cout\n",
    " << \"type\\tbits\\tmin\\t\\tmax\\n\"\n",
    " << \"int\\t\" << sizeof(int)*8 << \"\\t\"\n",
    " << std::numeric_limits<int>::min() << '\\t'\n",
    " << std::numeric_limits<int>::max() << '\\n'\n",
    " << \"float\\t\" << sizeof(float)*8 << \"\\t\"\n",
    " << std::numeric_limits<float>::min() << '\\t'\n",
    " << std::numeric_limits<float>::max() << '\\n' \n",
    " << \"double\\t\" << sizeof(double)*8 << \"\\t\"\n",
    " << std::numeric_limits<double>::min() << '\\t' \n",
    " << std::numeric_limits<double>::max() << '\\n' ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## New in C++11: fixed size integer types\n",
    "\n",
    "C++11 borrows from C99 a bunch of integer types following different rules:\n",
    "- good for memory, the smallest with at least N bits: `int_least8_t`, `int_least16_t`, `int_least32_t`, `int_least64_t` ;\n",
    "- good for performance, the fastest with at least N bits: `int_fast8_t`, `int_fast16_t`, `int_fast32_t`, `int_fast64_t` ;\n",
    "- good for portability, with exactly N bits: `int8_t`, `int16_t`, `int32_t`, `int64_t`.\n",
    "\n",
    "They are availables when including `<cstdint>`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Hardly predictable precision\n",
    "\n",
    "When an operation mix variables with different precisions, the compiler casts all the operands to the ***best*** precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "float f = std::numeric_limits<float>::max() ;\n",
    "std::cout<<( f * 10.f )<<std::endl ;\n",
    "std::cout<<( f * 10.  )<<std::endl ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Floating point types are considered better than integer types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "float f = std::numeric_limits<float>::max() ;\n",
    "std::cout<<( f * 10 )<<std::endl ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`unsigned` types are considered better than their `signed` flavor..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "unsigned int i = 1 ;\n",
    "int j = -1 ;\n",
    "std::cout<<( i * j )<<std::endl ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Sometimes, computation is performed with a precision higher than the original variables. For example, a `short` based operation will always be evaluated as an `int` (because `int` is the same size as the hardware registers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "short s1 = std::numeric_limits<short>::max() ;\n",
    "short s2 = 1 ;\n",
    "std::cout << (s1+s2) << std::endl ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "short s3 = (s1+s2) ;\n",
    "std::cout << s3 << std::endl ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**BEWARE**: Intel processors were typically computing their `double` operations with extraneous digits (80). One may think **the higher the precision, the better**. But it implies a **portability issue**, because the results will differ when running your code on a different processor, when vectorizing, when porting the code to GPU..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Unnoticed conversions\n",
    "\n",
    "For ease of writing code, C compilers and thus, C++ compilers as well, are authorized to perform multiple conversions between predefined numeric types. These so-called **implicit conversions** are automatic and often unnoticed by the developer. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Some of these allowed implicit conversions can introduce a loss of precision: for example a transformation from a floating-point number to an integer. The compiler assumes that such ***narrowing*** is done on purpose. Is it still a reasonable assumption for a code made of thousands of lines?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "double pi = 3.1416 ; \n",
    "int i = pi ;\n",
    "std::cout<<\"double \"<<pi<<\" => int \"<<i<<std::endl ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "long lmax = std::numeric_limits<long>::max() ;\n",
    "short s = lmax ;\n",
    "std::cout<<\"long \"<<lmax<<\" => short \"<<s<<std::endl ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "double dmax = std::numeric_limits<double>::max() ;\n",
    "float f = dmax ;\n",
    "std::cout<<\"double \"<<dmax<<\" => float \"<<f<<std::endl ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Even worse, the compiler can transform any signed/unsigned integer into unsigned/signed !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "void display_signed( short v )\n",
    " { std::cout<<v<<std::endl ; }\n",
    "\n",
    "unsigned short us = 42000 ;\n",
    "display_signed(us) ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "void display_unsigned( unsigned short v )\n",
    " { std::cout<<v<<std::endl ; }\n",
    "\n",
    "short s = -42 ;\n",
    "display_unsigned(s) ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "**BEWARE**: when mixing signed and unsigned integers in an expression, the compiler will consider the unsigned flavor as the most accurate, and transform all the integers accordingly. One more time, **paying attention to compiler warnings will help you out**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Disputed practice: never use unsigned numbers\n",
    "\n",
    "...if you can !\n",
    "- There are some contexts (embedded computing) where every bits is worth saving.\n",
    "- The standard library designers made the choice of unsigned integers for the size and indexes of all the containers :(\n",
    "\n",
    "My advice: for any size or index, use `std::size_t`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Good old-fashioned practice: make all conversions explicit\n",
    "\n",
    "In a program of a large size, implicit conversions are more of a hindrance than a help. It is advised to:\n",
    "- set the warning level to maximum,\n",
    "- scrutinize carefully all compiler warnings,\n",
    "- make explicit any conversion you identify in the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The C way, for explicit conversions, is to use the type name as a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "unsigned short i = 42000 ;\n",
    "short j = short(i) ; \n",
    "std::cout<<j<<std::endl ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "But this does not catch the eye. Better, C++ comes with a set of explicit type casting operators. The one to be used by default is `static_cast`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "unsigned short i = 42000 ;\n",
    "short j = static_cast<short>(i) ;\n",
    "std::cout<<j<<std::endl ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Three other type casting operators are available, for rare specific use-cases:\n",
    "* `const_cast` : in rare cases, when one wants to get rid of the constness of a variable;\n",
    "* `dynamic_cast` : to goes down an inheritance tree;\n",
    "* `reinterpret_cast` : in very rare cases, when one wants to change the way a memory chunk is interpreted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## User-defined numerical types\n",
    "\n",
    "If you are daredevil enough to develop your own numerical type, you may want to provide a constructor and/or a conversion operator, so to ease interaction with functions which generate and/or require doubles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***restart kernel***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#include <iostream>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Number\n",
    " {\n",
    "  public :\n",
    "    Number( double f ) { std::cout<<\"double_to_number\"<<std::endl ; }\n",
    "    operator double() { std::cout<<\"number_to_double\"<<std::endl ; return 0 ; }\n",
    " } ;  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Number number_pi(3.14) ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "void foo_double( double ) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "foo_double(number_pi) ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "void foo_number( Number ) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "foo_number(3.14) ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "BEWARE: the unary constructor, and the conversion operator, opens the door for **implicit conversions**. The compiler can even chain several ones, such as `short` => `double` => `Number` below, or the contrary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "short sh = 42 ;\n",
    "foo_number(sh) ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "void foo_short( short ) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "foo_short(number_pi) ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Good old-fashioned practice: make unary constructors explicit\n",
    "\n",
    "The implicit conversions problem does not only apply to numerical classes. It is true for any class which has a unary constructor (constructor with only one argument).\n",
    "\n",
    "The keyword `explicit` forbids the use of those unary constructors for implicit conversions. It should be used almost always."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***restart kernel***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#include <iostream>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Number\n",
    " { \n",
    "  public :\n",
    "    explicit Number( double f ) { std::cout<<\"double_to_number\"<<std::endl ; }\n",
    "    operator double() { std::cout<<\"number_to_double\"<<std::endl ; return 0 ; }\n",
    " } ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "void foo_number( Number ) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "foo_number(42) ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yet the implicit use of the conversion operator is still ok."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Number number_pi(3.14) ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "void foo_double( double ) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "foo_double(number_pi) ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## New in C++11 : explicit conversion operators\n",
    "\n",
    "The keyword `explicit` has been generalized to conversion operators within C++11."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***restart kernel***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#include <iostream>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Number\n",
    " { \n",
    "  public :\n",
    "    explicit Number( double f ) { std::cout<<\"double_to_number\"<<std::endl ; }\n",
    "    explicit operator double() { std::cout<<\"number_to_double\"<<std::endl ; return 0 ; }\n",
    " } ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "void display_double( double ) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Number value(3.14) ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display_double(value) ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Take Away\n",
    "\n",
    "- I use *unsigned integers* only for sizes and indexes.\n",
    "- Implicit conversions are a major source of bugs in ancient C++.\n",
    "- Modern C++ provides different ways to take the control back:\n",
    "  - explicit constructors and converters,\n",
    "  - forbidden overloads (to be seen later),\n",
    "  - **universal initialization**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Questions ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# References\n",
    "\n",
    "Types\n",
    "* [Cpp Reference](https://en.cppreference.com/w/cpp/language/types)\n",
    "* [Fixed size integer types](https://en.cppreference.com/w/cpp/types/integer)\n",
    "\n",
    "Implicit conversions\n",
    "- [Cpp Reference](https://en.cppreference.com/w/cpp/language/implicit_conversion)\n",
    "- [LearnCPP](https://www.learncpp.com/cpp-tutorial/implicit-type-conversion/)\n",
    "- [Nothing But](https://dbj.org/how-to-avoid-implicit-conversion-in-c/)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "© *CNRS 2024*  \n",
    "*This document was created by David Chamont and translated by Olga Abramkina. It is available under the [Licence Creative Commons - Attribution - No commercial use - Shared under the conditions 4.0 International](http://creativecommons.org/licenses/by-nc-sa/4.0/)*"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "17"
  },
  "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
}