Module A-Section 9.1, 9.2, 9.3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module A: Section 9.1, 9.2, 9.3\n",
    "## Problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from math import floor, log\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a function my_bin_2_dec(b) where b is binary number represented by a list of ones and zeros. The last element of b represents the coefficient of 20, the second-to-last element of b represents the coefficient of 21, and so on. The output variable, d, should be the decimal representation of b. The test cases are provided below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def my_bin_2_dec(b: list) -> int:\n",
    "    \"\"\"\n",
    "    Convert binary number to decimal.\n",
    "    :param b: Binary number represented by a list of ones and zeros.\n",
    "    :return: Decimal representation of b.\n",
    "    \"\"\"\n",
    "    # Initialize output decimal number to 0.\n",
    "    d = 0\n",
    "\n",
    "    # Length of binary number.\n",
    "    n = len(b)\n",
    "\n",
    "    \"\"\"\n",
    "    Example:\n",
    "    b:      [1,0,1,0,1,0]\n",
    "    index:  [0,1,2,3,4,5]\n",
    "    len (n): 6\n",
    "\n",
    "    k is the power of 2.\n",
    "    k:      [5,4,3,2,1,0]\n",
    "    k = n - i - 1\n",
    "    \"\"\"\n",
    "\n",
    "    # Loop through binary number.\n",
    "    for i in range(n):\n",
    "        k = n - i - 1\n",
    "        d += b[i] * (2 ** k)\n",
    "\n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "7"
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: 7\n",
    "my_bin_2_dec([1, 1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "85"
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: 85\n",
    "my_bin_2_dec([1, 0, 1, 0, 1, 0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "33554431"
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: 33554431\n",
    "my_bin_2_dec([1]*25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Write a function my_dec_2_bin(d), where d is a positive integer in decimal, and b is the binary representation of d. The output b must be a list of ones and zeros, and the leading term must be a 1 unless the decimal input value is 0. The test cases are provided below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def my_dec_2_bin(d: int) -> list:\n",
    "    \"\"\"\n",
    "    Convert decimal to binary.\n",
    "    :param d: Decimal number.\n",
    "    :return: Binary number represented by a list of ones and zeros.\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize output binary number to empty list.\n",
    "    b = []\n",
    "\n",
    "    # Loop until d is 0\n",
    "    while d != 0:\n",
    "        # Append 1 to b if d is odd\n",
    "        if d % 2 == 1:\n",
    "            b.append(1)\n",
    "        # Append 0 to b if d is even\n",
    "        else:\n",
    "            b.append(0)\n",
    "\n",
    "        # Divide d by 2\n",
    "        d = d // 2\n",
    "\n",
    "    # Reverse b\n",
    "    b.reverse()\n",
    "\n",
    "    # Manage empty list\n",
    "    if len(b) == 0:\n",
    "        b.append(0)\n",
    "\n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "[0]"
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: [0]\n",
    "my_dec_2_bin(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "[1, 0, 1, 1, 1]"
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: [1, 0, 1, 1, 1]\n",
    "my_dec_2_bin(23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "[1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1]"
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: [1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1]\n",
    "my_dec_2_bin(2097)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Use the two functions you wrote in problems 1 and 2 to compute d = my_bin_2_dec(my_dec_2_bin(12654)). Do you get the same number?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, we got the same number\n",
      "Input: 12654\n",
      "Output: 12654\n"
     ]
    }
   ],
   "source": [
    "d_in = 12654\n",
    "d_out = my_bin_2_dec(my_dec_2_bin(d_in))\n",
    "\n",
    "if d_out == d_in:\n",
    "    print(\"Yes, we got the same number\")\n",
    "else:\n",
    "    print(\"No, we got a different number\")\n",
    "\n",
    "print(\"Input:\", d_in)\n",
    "print(\"Output:\", d_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Write a function my_bin_adder(b1,b2), where b1, b2 and the output variable b are binary numbers represented as in problem 1. The output variable should be computed as b = b1 + b2. Do not use your functions from problems 1 and 2 to write this function (i.e., do not convert b1 and b2 to decimal; add them, and then convert the result back to binary). This function should be able to accept inputs b1 and b2 of any length (i.e., very long binary numbers), and b1 and b2 may not necessarily be the same length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def my_bin_adder(b1: list, b2: list) -> list:\n",
    "    \"\"\"\n",
    "    Add two binary numbers.\n",
    "    :param b1: First binary number.\n",
    "    :param b2: Second binary number.\n",
    "    :return:  Sum of b1 and b2.\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize output binary number to empty list.\n",
    "    b = []\n",
    "\n",
    "    # Initialize carry to 0.\n",
    "    carry = 0\n",
    "\n",
    "    # Reverse b1 and b2.\n",
    "    b1.reverse()\n",
    "    b2.reverse()\n",
    "\n",
    "    # Loop through b1 and b2 and add\n",
    "    while (len(b1) != 0) and (len(b2) != 0):\n",
    "        _sum = b1[0] + b2[0] + carry\n",
    "\n",
    "        if _sum > 1:\n",
    "            carry = 1\n",
    "            _sum -= 2\n",
    "        else:\n",
    "            carry = 0\n",
    "\n",
    "        # Append sum\n",
    "        b.append(_sum)\n",
    "\n",
    "        #Pop elements\n",
    "        b1.pop(0)\n",
    "        b2.pop(0)\n",
    "\n",
    "    # Remaining elements\n",
    "    if len(b1) != 0:\n",
    "        r = b1\n",
    "    else:\n",
    "        r = b2\n",
    "\n",
    "    # Loop until carry is 0\n",
    "    while carry != 0:\n",
    "        if len(r) != 0:\n",
    "            _sum = r[0] + carry\n",
    "\n",
    "            if _sum >= 2:\n",
    "                carry = 1\n",
    "                _sum -= 2\n",
    "            else:\n",
    "                carry = 0\n",
    "\n",
    "            b.append(_sum)\n",
    "            r.pop(0)\n",
    "        else:\n",
    "            b.append(carry)\n",
    "            carry = 0\n",
    "\n",
    "    # Add remaining elements\n",
    "    b.extend(r)\n",
    "\n",
    "    # Reverse output b\n",
    "    b.reverse()\n",
    "\n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "[1, 0, 0, 0, 0, 0]"
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: [1, 0, 0, 0, 0, 0]\n",
    "my_bin_adder([1, 1, 1, 1, 1], [1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "[1, 1, 1, 0, 0, 1, 1]"
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: [1, 1, 1, 0, 0, 1, 1]\n",
    "my_bin_adder([1, 1, 1, 1, 1], [1, 0, 1, 0, 1, 0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "[1, 0, 1, 1]"
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Output: [1, 0, 1, 1]\n",
    "my_bin_adder([1, 1, 0], [1, 0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. What is the effect of allocating more bits to the fraction versus the characteristic and vice versa? What is the effect of allocating more bits to the sign?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming that the total number of bits remains the same, allocating more bits to the fraction would increase the accuracy and length of the fractional part of the float while decreasing the integer part. Similarly, allocating more bits to the characteristic would increase the accuracy and length of the integer part while decreasing the accuracy and length of the fractional part of the float.\n",
    "While the aforementioned parts might be useful to some degree, allocating more bits to the sign would virtually add no value as there can be only two signs adn can therefore be represented by 1 bit. Therefore, assigning more bits to the sign would simply reduce the accuracy and length of the integer and fractional part of the float while providing no benefit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "6. Write a function my_ieee_2_dec(ieee), where ieee is a string contains 64 characters of ones and zeros representing a 64-bit IEEE754 number. The output should be d, the equivalent decimal representation of ieee. The input variable ieee will always be a 64-element string of ones and zeros defining a 64-bit float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def my_ieee_2_dec(ieee) -> int | float:\n",
    "   \"\"\"\n",
    "    Convert ieee string to decimal\n",
    "    :param ieee: String containing 64 characters of ones and zeros representing a 64-bit IEEE754 number\n",
    "    :return: The equivalent decimal representation of ieee string\n",
    "   \"\"\"\n",
    "\n",
    "   # Split ieee\n",
    "   sign_bin = ieee[0]\n",
    "   exp_bin = ieee[1:12]\n",
    "   frac_bin = ieee[12:]\n",
    "\n",
    "   # Get the sign\n",
    "   if sign_bin == '1':\n",
    "       sign = -1\n",
    "   else:\n",
    "       sign = 1\n",
    "\n",
    "   # Get the exponent\n",
    "   exp = 0\n",
    "   len_exp_bin = len(exp_bin)\n",
    "   for i in range(0, len_exp_bin):\n",
    "        k = len_exp_bin - i - 1\n",
    "        exp += int(exp_bin[i]) * (2 ** k)\n",
    "   exp -= 1023\n",
    "\n",
    "   # Get the fraction\n",
    "   frac = 0\n",
    "   len_frac_bin = len(frac_bin)\n",
    "   for i in range(0, len_frac_bin):\n",
    "       frac += int(frac_bin[i]) * 2 ** (-1 * (i + 1))\n",
    "\n",
    "   d = sign * ((2 ** exp) * (1 + frac))\n",
    "   return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-48.0\n"
     ]
    }
   ],
   "source": [
    "# Output: -48\n",
    "ieee_string = '1100000001001000000000000000000000000000000000000000000000000000'\n",
    "print(my_ieee_2_dec(ieee_string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4\n"
     ]
    }
   ],
   "source": [
    "# Output: 3.39999999999999991118215802999\n",
    "ieee_string = '0100000000001011001100110011001100110011001100110011001100110011'\n",
    "print(my_ieee_2_dec(ieee_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Write a function my_dec_2_ieee(d), where d is a number in decimal and output variable ieee is a string with 64 characters of ones and zeros representing the 64-bit IEEE754 closest to d. You can assume that d will not cause an overflow for 64-bit ieee numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def my_dec_2_ieee(d) -> str:\n",
    "    \"\"\"\n",
    "    Convert decimal to 64-bit IEEE754 String\n",
    "    :param d: Decimal Number\n",
    "    :return: 64-bit IEEE754 String\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize output binary to empty list\n",
    "    b = []\n",
    "\n",
    "    # Get the sign\n",
    "    if d < 0:\n",
    "        sign = 1\n",
    "    else:\n",
    "        sign = 0\n",
    "\n",
    "    # Get the characteristic\n",
    "    char_int = floor(log(abs(d), 2))\n",
    "    char = char_int + 1023\n",
    "    char_bin = my_dec_2_bin(char)\n",
    "\n",
    "    while len(char_bin) < 11:\n",
    "        char_bin_copy = char_bin.copy()\n",
    "        char_bin = [0] + char_bin_copy\n",
    "\n",
    "    # Get the fraction\n",
    "    frac = (d / (((-1) ** sign) * (2 ** char_int))) - 1\n",
    "\n",
    "    def frac_2_bin(f: float) -> list:\n",
    "        \"\"\"\n",
    "        Convert a fractional value to binary\n",
    "        :param f: fractional value (< 1)\n",
    "        :return: Binary number represented by a list of ones and zeros.\n",
    "        \"\"\"\n",
    "\n",
    "        fb = []\n",
    "\n",
    "        while len(fb) < 52:\n",
    "            f = f * 2\n",
    "\n",
    "            if f > 1:\n",
    "                fb.append(1)\n",
    "                f -= 1\n",
    "            else:\n",
    "                fb.append(0)\n",
    "\n",
    "        if (f * 2) > 1:\n",
    "            fb = my_bin_adder(fb, [1])\n",
    "\n",
    "        return fb\n",
    "\n",
    "    frac_bin = frac_2_bin(abs(frac))\n",
    "\n",
    "    # Combine binary lists\n",
    "    b.append(sign)\n",
    "    b.extend(char_bin)\n",
    "    b.extend(frac_bin)\n",
    "\n",
    "    # Convert b from list of ints to strings\n",
    "    b = [str(ints) for ints in b]\n",
    "\n",
    "    # Convert bin list to str\n",
    "    ieee = ''.join(b)\n",
    "\n",
    "    return ieee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0011111111111000010010111011011000010110100011100001110100100000\n"
     ]
    }
   ],
   "source": [
    "# Output: '0100000000101110010111101010001110011100001100011010010001101000'\n",
    "\n",
    "d_in = 1.518484199625\n",
    "print(my_dec_2_ieee(d_in))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1100000001110011010100100100010010010001001010011000100010010000\n"
     ]
    }
   ],
   "source": [
    "# Output: '1100000001110011010100100100010010010001001010011000100010010000'\n",
    "\n",
    "d_in = -309.141740\n",
    "print(my_dec_2_ieee(d_in))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1100000011011000101010010000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "# Output: '1100000011011000101010010000000000000000000000000000000000000000'\n",
    "\n",
    "d_in = -25252\n",
    "print(my_dec_2_ieee(d_in))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Define ieee_baby to be a representation of numbers using 6 bits where the first bit is the sign bit, the second and third bits are allocated to the characteristic, and the fourth, fifth, and sixth bits are allocated to the fraction. The normalization for the characteristic is 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "ieee_baby = '001010'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write all the decimal numbers that can be represented by ieee_baby. What is the largest/smallest gap in ieee_baby?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 64 possible ieee_baby numbers.\n",
      "\n",
      "All possible decimal numbers represented by ieee_baby are: \n",
      "[-7.787758504775205e-308, -6.675221575521604e-308, -5.562684646268003e-308, -4.450147717014403e-308, -3.8938792523876024e-308, -3.337610787760802e-308, -3.337610787760802e-308, -2.7813423231340017e-308, -2.2250738585072014e-308, -2.2250738585072014e-308, -1.946939626193801e-308, -1.668805393880401e-308, -1.668805393880401e-308, -1.390671161567001e-308, -1.1125369292536007e-308, -1.1125369292536007e-308, -1.1125369292536007e-308, -9.734698130969006e-309, -8.344026969402005e-309, -8.344026969402005e-309, -6.953355807835004e-309, -5.562684646268003e-309, -5.562684646268003e-309, -5.562684646268003e-309, -4.172013484701003e-309, -2.781342323134e-309, -2.781342323134e-309, -1.390671161567e-309, 0.0, 0.0, 0.0, 0.0, -0.0, -0.0, -0.0, -0.0, 1.390671161567e-309, 2.781342323134e-309, 2.781342323134e-309, 4.172013484701003e-309, 5.562684646268003e-309, 5.562684646268003e-309, 5.562684646268003e-309, 6.953355807835004e-309, 8.344026969402005e-309, 8.344026969402005e-309, 9.734698130969006e-309, 1.1125369292536007e-308, 1.1125369292536007e-308, 1.1125369292536007e-308, 1.390671161567001e-308, 1.668805393880401e-308, 1.668805393880401e-308, 1.946939626193801e-308, 2.2250738585072014e-308, 2.2250738585072014e-308, 2.7813423231340017e-308, 3.337610787760802e-308, 3.337610787760802e-308, 3.8938792523876024e-308, 4.450147717014403e-308, 5.562684646268003e-308, 6.675221575521604e-308, 7.787758504775205e-308]\n",
      "\n",
      "Smallest gap: 5e-324\n",
      "Largest gap: 1e-323\n"
     ]
    }
   ],
   "source": [
    "# Initialize ieee_babies list\n",
    "ieee_babies = [[0, 0, 0, 0, 0, 0]]\n",
    "last_baby = [0, 0, 0, 0, 0, 0]\n",
    "\n",
    "# Get all possible ieee_baby numbers\n",
    "# Create all possible numbers with 6 bits of ones and zeros\n",
    "while last_baby != [1, 1, 1, 1, 1, 1]:\n",
    "    # Use adder to add 1 to last_baby to get next baby\n",
    "    next_baby = my_bin_adder(last_baby, [0, 0, 0, 0, 0, 1])\n",
    "\n",
    "    # Add next baby to list\n",
    "    ieee_babies.append(next_baby)\n",
    "    last_baby = next_baby.copy()\n",
    "\n",
    "def baby_2_dec(baby):\n",
    "    sign_bin = baby[0]\n",
    "    char_bin = baby[1: 3]\n",
    "    frac_bin = baby[3: ]\n",
    "\n",
    "    sign = (-1) ** sign_bin\n",
    "\n",
    "    char_dec = char_bin[0] * (2 ** 1) + char_bin[1] * (2 ** 0)\n",
    "    char = 2 ** (char_dec - 1023)\n",
    "\n",
    "    frac = frac_bin[0] * (2 ** (-1 * 1)) + frac_bin[1] * (2 ** (-1 * 2)) + frac_bin[2] * (2 ** (-1 * 3))\n",
    "\n",
    "    return sign * char * frac\n",
    "\n",
    "\n",
    "# All the decimal numbers that can be represented by ieee_baby. What is the largest/smallest gap in ieee_baby?\n",
    "ieee_baby_decimals = []\n",
    "for _ieee_baby in ieee_babies:\n",
    "    ieee_baby_decimals.append(baby_2_dec(_ieee_baby))\n",
    "\n",
    "\n",
    "# Sort\n",
    "ieee_baby_decimals.sort()\n",
    "\n",
    "# Print total number of ieee_baby numbers\n",
    "# Should be 2^6 = 64\n",
    "print(f\"There are {len(ieee_baby_decimals)} possible ieee_baby numbers.\\n\")\n",
    "\n",
    "# Print all decimals\n",
    "print(\"All possible decimal numbers represented by ieee_baby are: \")\n",
    "print(ieee_baby_decimals)\n",
    "\n",
    "# Find the gaps in the ieee_baby numbers\n",
    "spaces = abs(np.spacing(ieee_baby_decimals))\n",
    "\n",
    "# Print the largest and smallest gap\n",
    "print(f\"\\nSmallest gap: {min(spaces)}\")\n",
    "print(f\"Largest gap: {max(spaces)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "11. Write the number 13 (base10) in base1. How would you do addition and multiplication in base1?\n",
    "* **13(Base 10) -> 1111111111 (Base 1)**\n",
    "* **Addition: Add the numbers of bits.** Let x have 2 bits and y have 5 bits, z=x+y will have 2+=7 bits. Example: 11111 + 111 = 11111111.\n",
    "* **Multiplication: Multiply the number of bits.** Let x have 2 bits and y have 5 bits, then z=x*y will have 2 * 5=10 bits. Example: 111 * 11 = 111111."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "13. How high can you count on your fingers if you count in binary?\n",
    "\n",
    "**We have 10 fingers, so we can represent upto 10 bits**. Therefore, 111111111 is the largest binary number we can represent with our fingers, which equals 2047 in decimal (base 10).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "13. Let b be a binary number having n digits. Can you think of ways to multiply and divide b by 2 that does not involve any arithmetic? Hint: Think about how you multiply and divide a decimal number by 10.\n",
    "\n",
    "**Bit Shifting**. Shifting bits to the left or right.\n",
    "* Bit Shifting * is a fast way to multiply or divide a number by 2.\n",
    "* Bit shifting to the left is an easy way to multiply by 2 per bit shifted. **Example**: 1111 * 10 = 11110 and 1111 * 100 = 111100.\n",
    "* Bit shifting to the right is an easy way to divide by 2 per bit shifted. **Example**: 111100 / 10 = 11110 and 111100/100 = 1111.\n",
    "*Note: Examples are with binary numbers so 10 is 2 in base 10 and 100 is 4 in base 10.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}