{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Number Representations\n", "\n", "This treatment loosely follows the treatment in TAK, Chapter 2.\n", "\n", "Mathematical topics covered:\n", "* Integer representations in various bases, especially base 16 and base 2.\n", "* Floating point numbers in various bases.\n", "\n", "Programming concepts covered:\n", "* converting to and from hexadecimal\n", "* while loops\n", "* floating point numbers\n", "* special floating point numbers\n", "* printing floating point numbers\n", "* using `assert` for checking input\n", "* catching errors with the `try` statement\n", "* NumPy's higher precision `float128` type\n", "* mpmath's multiple precision float type: `mpf`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In Python a floating point real number is of type float. You can define a float using a number including a decimal. They are also the type of numbers that arise from (standard) division even if the quotient is an integer. You can test if a number is a float by evaluating its type, e.g., `type(num)`." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(3.14)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(2/1)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(2//1)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from math import pi\n", "type(pi)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Floats in Python are floating point numbers following the IEEE Floating Point Standards. We will learn what this means. First we should review numbers in other bases." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Integer representations in various bases" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let $\\beta \\geq 2$ be an integer. Then we can represent each non-negative integer by a finite sequence of numbers in the set $\\{0,1,2,\\ldots,\\beta-1\\}$. Namely, if $(a_n,a_{n-1}, \\ldots, a_0)$ is a finite sequence with each $a_i \\in \\{0,1,2,\\ldots,\\beta-1\\}$, it represents the number\n", "$$\\sum_{k=0}^n a_k \\beta^k.$$\n", "Numbers are ordered like in decimal in order from most signficant to least significant. We usually assume that the most significant number in the sequence (i.e., $a_n$) is non-zero, but often in computers we allow zeros but limit the length of the sequence.\n", "\n", "There some important special cases:\n", "* Base 10 representations are said to be *decimal representations*.\n", "* Base 2 representations are said to be *binary representations*.\n", "* Base 16 representations are said to be *hexadecimal representations*. Often hexadecimal is abbreviated as *hex*.\n", "\n", "**Examples**\n", "The number $14$ has binary representation $1110$ since $14=8+4+2$.\n", "\n", "In base 16, we represent the numbers $\\{0,\\ldots, 15\\}$ by switching to letters once we run out of digits. So, we use\n", "$$\\{0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f\\}$$\n", "with $a=10$, $b=11$, $c=12$, $d=13$, $e=14$ and $f=15$. So for example, $415$ would be represented as `19f` since\n", "$$415 = 1 \\cdot (16)^2 + 9 \\cdot 16 + 15.$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Working with hexadecimal numbers\n", "\n", "Python has built in support for converting integers into hexadecimal through the `hex` function. Observe:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'0xc'" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hex(12)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'0x19f'" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hex(415)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'-0x2b'" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hex(-43)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'0x0'" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hex(0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the output of `hex` is a string. The first character is `-` if the number is negative, and then the subsequent two characters are `0x`. In the case of a non-negative number the first two characters are `0x`. The `0x` is there to indicate that we are dealing with a hexadecimal number.\n", "\n", "Python also accepts integers input in hexadecimal as illustrated below." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "37" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "0x25" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-31" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "-0x1f" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To convert a string holding a hexadecimal representation to an integer, you simply need to get Python to evaluate the string as input. This can be done with the `eval` command as shown below." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "36" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eval('0x24')" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-255" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eval('-0xff')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In particular, for any integer `n`, the operation `eval(hex(n))` returns `n`." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "23" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eval(hex(23))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Working with binary numbers\n", "\n", "Binary numbers can be worked with in a similar way to hexadecimal numbers. Python has a built in function `bin` which converts to binary. For example:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'0b1011'" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bin(11)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The above output makes sense since $11=8+2+1$. The following checks the behavior of negative numbers and zero." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'-0b1011'" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bin(-11)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'0b0'" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bin(0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Again, integers can be entered in binary." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "11" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "0b1011" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-11" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "-0b1011" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "11" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eval(\"0b1011\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Working with other bases\n", "\n", "Python doesn't have a built in way to convert from an integer to other bases and back. We will do it by hand in base $3$, and learn some basic programming skills in the process.\n", "\n", "A base $3$ is also called a *ternary representation*. Digits in ternary are known as *trits*. They take the value `0`, `1`, or `2`.\n", "\n", "First lets discuss an example. Lets think about how we would find the ternary representation of $64$ as part of a repetitive process. \n", "* The rightmost trit of the ternary expansion of $64$ is `1`, because $64=3\\times 21+1$. The remainder of the expansion coincides with the expansion of $21$.\n", "* The rightmost trit of the expansion of $21$ is `0`, because $21$ is a multiple of three. In fact, $21=3 \\times 7$, so the remainder of the expansion coincides with the expansion of $7$.\n", "* The rightmost trit of the expansion of $7$ is `1`, because $7=3\\times 2+1$. The remainder of the expansion coincides with the expansion of $2$.\n", "* The rightmost trit of $2$ is `2`. Since $2=3 \\times 0 + 2$, we can stop.\n", "\n", "From the above we see that the ternary expansion of $64$ is `2101`. We have found the trits from right to left following the bullets above.\n", "\n", "In particular observe that we can find the rightmost trit of a non-negative number using modular division by $3$. For example:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "64 % 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that we will want to output a string instead of an integer, so we will make use of the `str` function to convert an object or number to a string." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'1'" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "str(64 % 3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This gives the right-most trit. The remainder of the trits give the ternary expansion of the number obtained through integer division by $3$. Namely," ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "21" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "64 // 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can implement this repetitive process using a while loop. A while loop has the syntax.\n", "\n", "
\n", "while condition:\n", " statement1\n", " statement2\n", "\n", "\n", "The while command as above repeatedly runs the indented statements until condition becomes false. \n", "\n", "Here we make use of the while statement to carry out the above computation of the trits for $64$." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Found trit is '1'.\n", "Changed n to 21.\n", "Found trit is '0'.\n", "Changed n to 7.\n", "Found trit is '1'.\n", "Changed n to 2.\n", "Found trit is '2'.\n", "Changed n to 0.\n" ] } ], "source": [ "n = 64\n", "while n != 0: # Run the following loop until n becomes zero.\n", " trit = n % 3\n", " print(\"Found trit is '{}'.\".format(trit))\n", " n = n // 3 # Update the value of n.\n", " print(\"Changed n to {}.\".format(n))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that if `string` is a string containing `{}`, then `string.format(obj)` returns the string but with `{}` replaced by `str(obj)`. \n", "\n", "We have used print statements above to keep track of the values of the variables in the loop. We can see for instance when we order the trits from right to left, we get `2101`, which is what we wanted.\n", "\n", "We can form `2101` by repeated concatenations of strings. We concatenate strings with the `+` operator. This was discussed earlier. For example `'abc'+'def'` will return `abcdef`.\n", "\n", "Below, we take what we did above and include it in a function. We also perform the concatenation of trits using string concatenation." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "def ternary(n):\n", " rep = '' # This will store the ternary representation.\n", " while n != 0:\n", " trit = n % 3\n", " rep = str(trit) + rep # add the new trit on the left.\n", " print(\"Our current representation is '{}'.\".format(rep))\n", " n = n // 3\n", " return rep" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Our current representation is '1'.\n", "Our current representation is '01'.\n", "Our current representation is '101'.\n", "Our current representation is '2101'.\n" ] }, { "data": { "text/plain": [ "'2101'" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ternary(64)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the output above, we can see we have correctly concatenated. The output above `2101` is the ternary expansion of $64$ as desired." ] }, { "attachments": { "crash.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "It would be good to remove the print statement in the final version. But there are some other issues with the code.\n", "\n", "What happens if $n$ is zero? What about if $n$ is negative?\n", "\n", "In the negative case, $n$ will stay negative! This means our `while` loop will never terminate. I attempted to run it anyway and saw the following error:\n", "![crash.png](attachment:crash.png)\n", "\n", "I had to go to the menu entry *Kernel > Interupt* to get execution to stop." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To avoid the possibility of this, we will test our input before entering the `while` loop. The `assert` statement is good for this. The syntax is \n", "
assert condition, error_string\n", "The *error_string* is printed and execution is stopped if the *condition* is false. If *condition* is true, then execution continues unhindered and nothing is printed." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "I guess one plus one is two.\n" ] } ], "source": [ "assert 1+1 == 2, \"But, 1+1==2 should aways be true!\"\n", "print(\"I guess one plus one is two.\")" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "ename": "AssertionError", "evalue": "Error: 1+1 is not three!", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m