{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Float conversion\n", "\n", "I came up with the following question $(float64)x < (float64)y \\Longrightarrow (float32) x < (float32)y$? What is the probability this holds?"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = -1;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": ["%matplotlib inline"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Probability (float64)x == (float32)x\n", "\n", "Let's evaluate how many time we draw a random double number equal to its float conversion."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"data": {"text/plain": ["((100000000,), dtype('float64'))"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy\n", "rnd = numpy.random.random(100000000)\n", "rnd.shape, rnd.dtype"]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/plain": ["2"]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["rnd32 = rnd.astype(numpy.float32).astype(numpy.float64)\n", "equal = (rnd == rnd32).sum()\n", "equal"]}, {"cell_type": "markdown", "metadata": {}, "source": ["It is very low. Let's check the reverse is true."]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"text/plain": ["100000000"]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}], "source": ["rnd32b = rnd32.astype(numpy.float64).astype(numpy.float32)\n", "equal = (rnd32b == rnd32).sum()\n", "equal"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Let's study the distribution of the difference."]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [{"data": {"text/plain": ["(-2.9802321610539195e-08, 2.9802320611338473e-08)"]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["delta = rnd - rnd32\n", "numpy.min(delta), numpy.max(delta)"]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"data": {"text/plain": ["(5.400330183036317e-10, 0.9999999976946683)"]}, "execution_count": 8, "metadata": {}, "output_type": "execute_result"}], "source": ["numpy.min(rnd), numpy.max(rnd)"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<matplotlib.figure.Figure at 0x20e075d7048>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["import matplotlib.pyplot as plt\n", "plt.hist(delta, bins=1000);"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We finally check that double operations between float numpers remain floats."]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": ["import random\n", "for i in range(0,100000):\n", "    i,j = random.randint(0, len(rnd32)-1), random.randint(0, len(rnd32)-1)\n", "    d32 = numpy.float64(rnd32[i] * rnd32[j])\n", "    d64 = numpy.float64(rnd32[i]) * numpy.float64(rnd32[j])\n", "    if d32 != d64:\n", "        raise Exception(\"Issue with somme={0} = {1} + {2}\".format(rnd32[i] + rnd32[j], rnd32[i], rnd32[j]))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Interval length distribution\n", "\n", "Let's imagine now we want to define an intervalle in which a double is converted to the same float. Let's find out about it length."]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"data": {"text/plain": ["(7.245554200022153e-12, 5.9604641222676946e-08)"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["def find_interval(x):\n", "    dx = numpy.abs(x - numpy.float32(x))  # usually not zero\n", "    dx /= 100\n", "    f = numpy.float32(x)\n", "    x1 = x\n", "    while numpy.float32(x1) == f:\n", "        x1 -= dx\n", "    x2 = x\n", "    while numpy.float32(x2) == f:\n", "        x2 += dx\n", "    return x1 + dx, x2 - dx\n", "\n", "length = numpy.zeros((2000,))\n", "for i in range(length.shape[0]):\n", "    x = rnd[i]\n", "    x1, x2 = find_interval(x)\n", "    length[i] = x2-x1   \n", "\n", "min(length), max(length)"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<matplotlib.figure.Figure at 0x20e372989e8>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["plt.hist(length, bins=50);"]}, {"cell_type": "markdown", "metadata": {}, "source": ["So we can approximate this interval by something like this:"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"text/plain": ["5.953141313241872e-08"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["ql = numpy.sort(length)[int(length.shape[0] * 0.8)]\n", "ql"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## An answer to the initial question\n", "\n", "Let's estimate $\\mathbb{P}\\left(x_{64} < y_{64} \\Longrightarrow x_{32} < y_{32} \\; | \\; |x-y| \\leqslant d\\right)$ ?"]}, {"cell_type": "code", "execution_count": 13, "metadata": {"scrolled": false}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["90 5.357827181917685e-08 : 638 991\n", "190 1.1310968495159557e-07 : 812 1018\n", "290 1.726410980840143e-07 : 889 1011\n", "390 2.32172511216433e-07 : 918 986\n", "490 2.9170392434885173e-07 : 901 981\n", "590 3.5123533748127045e-07 : 936 986\n", "690 4.1076675061368917e-07 : 964 1004\n", "790 4.702981637461079e-07 : 982 1021\n", "890 5.298295768785266e-07 : 964 998\n", "990 5.893609900109453e-07 : 946 975\n"]}, {"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>d</th>\n", "      <th>ratio</th>\n", "      <th>total</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>5.953141e-10</td>\n", "      <td>0.019447</td>\n", "      <td>977</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1.190628e-09</td>\n", "      <td>0.041879</td>\n", "      <td>979</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>1.785942e-09</td>\n", "      <td>0.065590</td>\n", "      <td>991</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>2.381257e-09</td>\n", "      <td>0.063000</td>\n", "      <td>1000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>2.976571e-09</td>\n", "      <td>0.072217</td>\n", "      <td>997</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["              d     ratio  total\n", "0  5.953141e-10  0.019447    977\n", "1  1.190628e-09  0.041879    979\n", "2  1.785942e-09  0.065590    991\n", "3  2.381257e-09  0.063000   1000\n", "4  2.976571e-09  0.072217    997"]}, "execution_count": 14, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas\n", "\n", "def inf_strict(x, y):\n", "    f1 = x < y\n", "    f2 = numpy.float32(x) < numpy.float32(y)\n", "    return f1, f2\n", "\n", "def count_events(fct):\n", "    rows = []\n", "    for di in range(1, 1001):\n", "        d = di * ql / 100\n", "        total = 0\n", "        ok = 0\n", "        rnd = numpy.random.random((2000*3,))\n", "        for i in range(0, rnd.shape[0], 3):\n", "            s = -1 if rnd[i+2] < 0.5 else 1\n", "            x, y = rnd[i], rnd[i] + rnd[i+1]*d*s\n", "            f1, f2 = fct(x, y)\n", "            if f1: \n", "                total += 1\n", "                if f2:\n", "                    ok += 1\n", "        if (di+10) % 100 == 0:\n", "            print(di, d, \":\", ok, total)\n", "        rows.append(dict(d=d, ratio=ok*1./total, total=total))\n", "\n", "    return pandas.DataFrame(rows)\n", "\n", "df = count_events(inf_strict)\n", "df.head()"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [{"data": {"text/plain": ["<matplotlib.axes._subplots.AxesSubplot at 0x20e376592e8>"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<matplotlib.figure.Figure at 0x20e3727b828>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["df.plot(x=\"d\", y=\"ratio\")"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"data": {"text/plain": ["<matplotlib.axes._subplots.AxesSubplot at 0x20e37aa48d0>"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<matplotlib.figure.Figure at 0x20e37aa6160>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["df.plot(x=\"d\", y=\"ratio\", logx=True)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## An answer to a similar question: what about not strict comparison?\n", "\n", "Let's estimate $\\mathbb{P}\\left(x_{64} \\leqslant y_{64} \\Longrightarrow x_{32} \\leqslant y_{32} \\; | \\; |x-y| \\leqslant d\\right)$ ?"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["90 5.357827181917685e-08 : 966 966\n", "190 1.1310968495159557e-07 : 1015 1015\n", "290 1.726410980840143e-07 : 1004 1004\n", "390 2.32172511216433e-07 : 991 991\n", "490 2.9170392434885173e-07 : 1015 1015\n", "590 3.5123533748127045e-07 : 975 975\n", "690 4.1076675061368917e-07 : 969 969\n", "790 4.702981637461079e-07 : 962 962\n", "890 5.298295768785266e-07 : 1032 1032\n", "990 5.893609900109453e-07 : 1000 1000\n"]}, {"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>d</th>\n", "      <th>ratio</th>\n", "      <th>total</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>5.953141e-10</td>\n", "      <td>1.0</td>\n", "      <td>996</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1.190628e-09</td>\n", "      <td>1.0</td>\n", "      <td>969</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>1.785942e-09</td>\n", "      <td>1.0</td>\n", "      <td>1004</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>2.381257e-09</td>\n", "      <td>1.0</td>\n", "      <td>979</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>2.976571e-09</td>\n", "      <td>1.0</td>\n", "      <td>1041</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["              d  ratio  total\n", "0  5.953141e-10    1.0    996\n", "1  1.190628e-09    1.0    969\n", "2  1.785942e-09    1.0   1004\n", "3  2.381257e-09    1.0    979\n", "4  2.976571e-09    1.0   1041"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["def inf_equal(x, y):\n", "    f1 = x <= y\n", "    f2 = numpy.float32(x) <= numpy.float32(y)\n", "    return f1, f2\n", "\n", "df2 = count_events(inf_equal)\n", "df2.head()"]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"data": {"text/plain": ["<matplotlib.axes._subplots.AxesSubplot at 0x20e37aec400>"]}, "execution_count": 18, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<matplotlib.figure.Figure at 0x20e37b8c550>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["ax = df.plot(x=\"d\", y=\"ratio\", logx=True, label=\"<\")\n", "df2.plot(x=\"d\", y=\"ratio\", logx=True, label=\"<=\", ax=ax)"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["90 5.357827181917685e-08 : 652 1008\n", "190 1.1310968495159557e-07 : 799 964\n", "290 1.726410980840143e-07 : 871 994\n", "390 2.32172511216433e-07 : 881 969\n", "490 2.9170392434885173e-07 : 961 1014\n", "590 3.5123533748127045e-07 : 906 958\n", "690 4.1076675061368917e-07 : 930 973\n", "790 4.702981637461079e-07 : 1004 1036\n", "890 5.298295768785266e-07 : 962 1012\n", "990 5.893609900109453e-07 : 972 1016\n"]}, {"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>d</th>\n", "      <th>ratio</th>\n", "      <th>total</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>5.953141e-10</td>\n", "      <td>0.024291</td>\n", "      <td>988</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1.190628e-09</td>\n", "      <td>0.044838</td>\n", "      <td>959</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>1.785942e-09</td>\n", "      <td>0.057769</td>\n", "      <td>1004</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>2.381257e-09</td>\n", "      <td>0.087000</td>\n", "      <td>1000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>2.976571e-09</td>\n", "      <td>0.091769</td>\n", "      <td>1057</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["              d     ratio  total\n", "0  5.953141e-10  0.024291    988\n", "1  1.190628e-09  0.044838    959\n", "2  1.785942e-09  0.057769   1004\n", "3  2.381257e-09  0.087000   1000\n", "4  2.976571e-09  0.091769   1057"]}, "execution_count": 19, "metadata": {}, "output_type": "execute_result"}], "source": ["def sup_strict(x, y):\n", "    f1 = x > y\n", "    f2 = numpy.float32(x) > numpy.float32(y)\n", "    return f1, f2\n", "\n", "df3 = count_events(sup_strict)\n", "df3.head()"]}, {"cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [{"data": {"text/plain": ["<matplotlib.axes._subplots.AxesSubplot at 0x20e37b94da0>"]}, "execution_count": 20, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<matplotlib.figure.Figure at 0x20e37c97710>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["ax = df.plot(x=\"d\", y=\"ratio\", logx=True, label=\"<\")\n", "df2.plot(x=\"d\", y=\"ratio\", logx=True, label=\"<=\", ax=ax)\n", "df3.plot(x=\"d\", y=\"ratio\", logx=True, label=\">\", ax=ax)"]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["90 5.357827181917685e-08 : 964 964\n", "190 1.1310968495159557e-07 : 1010 1010\n", "290 1.726410980840143e-07 : 1009 1009\n", "390 2.32172511216433e-07 : 990 990\n", "490 2.9170392434885173e-07 : 967 967\n", "590 3.5123533748127045e-07 : 1019 1019\n", "690 4.1076675061368917e-07 : 1013 1013\n", "790 4.702981637461079e-07 : 1020 1020\n", "890 5.298295768785266e-07 : 996 996\n", "990 5.893609900109453e-07 : 964 964\n"]}, {"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>d</th>\n", "      <th>ratio</th>\n", "      <th>total</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>5.953141e-10</td>\n", "      <td>1.0</td>\n", "      <td>1031</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1.190628e-09</td>\n", "      <td>1.0</td>\n", "      <td>1013</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>1.785942e-09</td>\n", "      <td>1.0</td>\n", "      <td>975</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>2.381257e-09</td>\n", "      <td>1.0</td>\n", "      <td>998</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>2.976571e-09</td>\n", "      <td>1.0</td>\n", "      <td>1022</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["              d  ratio  total\n", "0  5.953141e-10    1.0   1031\n", "1  1.190628e-09    1.0   1013\n", "2  1.785942e-09    1.0    975\n", "3  2.381257e-09    1.0    998\n", "4  2.976571e-09    1.0   1022"]}, "execution_count": 21, "metadata": {}, "output_type": "execute_result"}], "source": ["def sup_equal(x, y):\n", "    f1 = x >= y\n", "    f2 = numpy.float32(x) >= numpy.float32(y)\n", "    return f1, f2\n", "\n", "df4 = count_events(sup_equal)\n", "df4.head()"]}, {"cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [{"data": {"text/plain": ["<matplotlib.axes._subplots.AxesSubplot at 0x20e38d39e48>"]}, "execution_count": 22, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<matplotlib.figure.Figure at 0x20e37c750b8>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["ax = df.plot(x=\"d\", y=\"ratio\", logx=True, label=\"<\")\n", "df2.plot(x=\"d\", y=\"ratio\", logx=True, label=\"<=\", ax=ax)\n", "df3.plot(x=\"d\", y=\"ratio\", logx=True, label=\">\", ax=ax)\n", "df4.plot(x=\"d\", y=\"ratio\", logx=True, label=\">=\", ax=ax)"]}, {"cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["90 5.357827181917685e-08 : 999 999\n", "190 1.1310968495159557e-07 : 1019 1019\n", "290 1.726410980840143e-07 : 1013 1013\n", "390 2.32172511216433e-07 : 994 994\n", "490 2.9170392434885173e-07 : 1012 1012\n", "590 3.5123533748127045e-07 : 984 984\n", "690 4.1076675061368917e-07 : 1024 1024\n", "790 4.702981637461079e-07 : 982 982\n", "890 5.298295768785266e-07 : 966 966\n", "990 5.893609900109453e-07 : 1001 1001\n"]}, {"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>d</th>\n", "      <th>ratio</th>\n", "      <th>total</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>5.953141e-10</td>\n", "      <td>1.0</td>\n", "      <td>976</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1.190628e-09</td>\n", "      <td>1.0</td>\n", "      <td>983</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>1.785942e-09</td>\n", "      <td>1.0</td>\n", "      <td>1024</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>2.381257e-09</td>\n", "      <td>1.0</td>\n", "      <td>966</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>2.976571e-09</td>\n", "      <td>1.0</td>\n", "      <td>1016</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["              d  ratio  total\n", "0  5.953141e-10    1.0    976\n", "1  1.190628e-09    1.0    983\n", "2  1.785942e-09    1.0   1024\n", "3  2.381257e-09    1.0    966\n", "4  2.976571e-09    1.0   1016"]}, "execution_count": 23, "metadata": {}, "output_type": "execute_result"}], "source": ["def inf_strict_neg(x, y):\n", "    f1 = (-x) >= (-y)\n", "    f2 = (-numpy.float32(x)) >= (-numpy.float32(y))\n", "    return f1, f2\n", "\n", "dfn = count_events(inf_strict_neg)\n", "dfn.head()"]}, {"cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [{"data": {"text/plain": ["<matplotlib.axes._subplots.AxesSubplot at 0x20e391d8eb8>"]}, "execution_count": 24, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<matplotlib.figure.Figure at 0x20e3916c3c8>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["ax = df.plot(x=\"d\", y=\"ratio\", logx=True, label=\"<\")\n", "dfn.plot(x=\"d\", y=\"ratio\", logx=True, label=\"-1 x >=\", ax=ax)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Conclusion\n", "\n", "The result is expected. As soon as two float are rounded to the same value, the strict inequality no longer holds. However, if you need to write a code which has to handle double and float (in a template for example), you should use not strict inequalities. It is easier to compare the results but you should read some article like [Is < faster than <=?](https://stackoverflow.com/questions/12135518/is-faster-than). According to [Processing costs of non-strict\n", "versus strict comparison](http://www.crcummins.com/CRCProcessing.pdf), ``<`` is 5-10% faster than ``<=``."]}, {"cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": []}], "metadata": {"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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}