00_Element_Arithmetic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ARITHMETIC \n",
    "*is the art of computing by numbers. Its five principal rules are Numeration, Addition, Subtraction, Multiplication, and Division.*\n",
    "\n",
    "*Benjamin Greeleaf*\n",
    "\n",
    "<br><br>\n",
    "This section is primary taken from the book \"Greenleaf's introduction ... to the National Arithmetic on the inductive system\"<sup>[1]()</sup> from the 19° century, is a little refresh, and of course a new book: *Understanding Elementary Mathematics, a series of hands-on Workbook Modules\"*<sup>[2]()</sup>. the algorithms basically we can see in wikipedia. We can read a very nice article about bitwise [3](https://pythongeeks.org/bitwise-operators-in-python/), and a usefull [math book](https://math.libretexts.org/Bookshelves/Applied_Mathematics/Understanding_Elementary_Mathematics_(Harland))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tools**\n",
    "\n",
    "First some of the usefull routines to work with this excersises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([0, 1, 2, 3], [0, 4, 5, 6])\n",
      "([0, 1, 2, 3], [4, 5, 6, 0])\n",
      "['43', '52']\n"
     ]
    }
   ],
   "source": [
    "# Split a Integer in to a list to work with decimal 'scales'\n",
    "#\n",
    "def SplitInt(a):\n",
    "    b=[]\n",
    "    for each in (list(str(a))):each = b.append(int(each))\n",
    "    a=b.copy();del b\n",
    "    return a\n",
    "\n",
    "# Regularize the Lengh of 2 Integers, work with integers and strings of numbers\n",
    "#\n",
    "def RegularizeIntegerPartLengh(a,b):\n",
    "    if len(a)>len(b):\n",
    "        Long = len(a)\n",
    "    else:\n",
    "        Long = len(b)\n",
    "    if ( Long - len(a) ) > 0:\n",
    "        a.reverse()\n",
    "        for i in range( Long - len(a) ):\n",
    "            a.append(0)\n",
    "        a.reverse()\n",
    "    elif ( Long - len(b) ) > 0:\n",
    "        b.reverse()\n",
    "        for i in range( Long - len(b) ):\n",
    "            b.append(0)\n",
    "        b.reverse()\n",
    "    else: None\n",
    "    return a,b\n",
    "\n",
    "# Regularize the Lengh of 2 decimal portions, work with integers and strings of numbers\n",
    "#\n",
    "def RegularizeFractionalPartLengh(a,b):\n",
    "    if len(a)>len(b):\n",
    "        Long = len(a)\n",
    "    else:\n",
    "        Long = len(b)\n",
    "    if ( Long - len(a) ) > 0:\n",
    "        for i in range( Long - len(a) ):\n",
    "            a.append(0)\n",
    "    elif ( Long - len(b) ) > 0:\n",
    "        for i in range( Long - len(b) ):\n",
    "            b.append(0)\n",
    "    else: None\n",
    "    return a,b\n",
    "\n",
    "# Split integers and decimals of a float\n",
    "#\n",
    "def SplitFloat(a):\n",
    "    b=str(a).split('.')\n",
    "    return b\n",
    "\n",
    "\n",
    "def GetRange(a):\n",
    "    RangeInList = range(len(a)-1)\n",
    "    return RangeInList\n",
    "def GetMajorNum(a,b):\n",
    "    if a > b: return a\n",
    "    else: return b\n",
    "def GetMinorNum(a,b):\n",
    "    if a < b: return a\n",
    "    else: return b\n",
    "\n",
    "           \n",
    "n1='0123'\n",
    "n2=456\n",
    "n3=43.52\n",
    "print(RegularizeIntegerPartLengh(SplitInt(n1),SplitInt(n2)))\n",
    "print(RegularizeFractionalPartLengh(SplitInt(n1),SplitInt(n2)))\n",
    "print(SplitFloat(n3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numeration\n",
    "- Numeration teaches to express the value of numbers either by words or characters. In python count objects with the len() command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1.1,2.1,3.1,4.1,5.1]\n",
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Addition\n",
    "\n",
    "- Addition is the collecting of numbers together to find their sum. We can use almost 4 algos for this: 2Sum, Binary splitting, Pairwise summation and Kahan summation algorithm. The sum of integers is like all languajes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 31 + 2\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bitwise_add: 4\n"
     ]
    }
   ],
   "source": [
    "# Bitwise Int Addition\n",
    "def Bitwise_add(x,y):\n",
    "    while y != 0:\n",
    "        z = x & y # Transport the value\n",
    "        x = x ^ y # Sum Value\n",
    "        y = z << 1 # shift one bit the carry\n",
    "        #Return the process until be 0\n",
    "    else: return x\n",
    "#\n",
    "print('Bitwise_add: '+str(Bitwise_add(1,3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*let's start to explain:*\n",
    "\n",
    "- one in binary: 1 \n",
    "- Three: 11 \n",
    "\n",
    "Bitwise operators:\n",
    "\n",
    "| AND (&) | XOR (^) | Shift Left Operator (<<) |\n",
    "| --------------- | --------------- | --------------- |\n",
    "| 0 & 0 = 0 | 0 & 0 = 0 | Short: add a 0 at end |\n",
    "| 0 & 1 = 0 | 0 & 1 = 1 |  |\n",
    "| 1 & 0 = 1 | 1 & 0 = 1 |  |\n",
    "| 1 & 1 = 1 | 1 & 1 = 0 |  |\n",
    "\n",
    "sum(1,3):\n",
    "    while y != 0\n",
    "\n",
    "Then z : 1 & 3 == 1 & 11 == 1\n",
    "\n",
    "And x : 1 ^ 3 == 1 ^ 11 == 10\n",
    "\n",
    "And y : 1 << 1 == 10\n",
    "\n",
    "Other loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Kahan summation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.5"
      ]
     },
     "execution_count": 276,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kahan(x):   \n",
    "  accumulator = 0.0#            Prepare the accumulator\n",
    "  compensation = 0.0#           Compensation for lost low-order bits\n",
    "  for n in x:#                  For each element in x\n",
    "    ne = n - compensation#      error subtracted\n",
    "    total = accumulator + ne#   total minus error\n",
    "    compensation = total - accumulator - ne# determine error\n",
    "    accumulator = total #       new total\n",
    "  return accumulator\n",
    "\n",
    "a = [1.1,2.1,3.1,4.1,5.1]\n",
    "kahan(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pairwise summation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.499999999999998"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pairwise summation of an array\n",
    "# https://algowiki-project.org/en/Pairwise_summation_of_numbers\n",
    "\n",
    "def pairwise(x):\n",
    "    a = x.copy()\n",
    "    sum=0.0\n",
    "    for i in range(len(a)):\n",
    "        n = len(a)-1\n",
    "        if len(a) == 0: return sum\n",
    "        if len(a) == 1:#     base case: naive summation for a sufficiently small array\n",
    "            s1 = a[0]\n",
    "            del a[0]\n",
    "        else:#         divide and conquer: recursively sum two halves of the array\n",
    "            #m = int(n / 2)\n",
    "            s1 = a[0] + a[n]\n",
    "            del a[n]; del a[0]\n",
    "        sum = s1 + sum\n",
    "    del a; del sum; del s1; del i\n",
    "\n",
    "b = [1.1,2.1,3.1,4.1,5.1]\n",
    "\n",
    "pairwise(b)# Thank you IEEE 754 =)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nPENDIENTE\\n'"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Binary splitting summation of an array\n",
    "'''\n",
    "PENDIENTE\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nPENDIENTE\\n'"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2Sum summation of an array\n",
    "'''\n",
    "PENDIENTE\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nPENDIENTE\\n'"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Partitioning primary school method\n",
    "'''\n",
    "PENDIENTE\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.622851"
      ]
     },
     "execution_count": 339,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Algorithm for Addition (AA)\n",
    "# a primary school - Addition by hand -method\n",
    "\n",
    "def AdditionByHand(n1,n2):\n",
    "    c=[];d=[]\n",
    "    #Split decimals\n",
    "    a=str(n1).split('.');b=str(n2).split('.')\n",
    "    #Populate lists\n",
    "    c.append(a[0]);c.append(b[0])\n",
    "    d.append(a[1]);d.append(b[1])\n",
    "    # Determine the largest decimal places\n",
    "    d2 = d.copy()\n",
    "    if len(d[0]) > len(d[1]):\n",
    "        o = (10**((len(d[0])-len(d[1]))))\n",
    "        d2[1]=o*int(d[1])\n",
    "        p = len(d[0])\n",
    "    elif len(d[1]) > len(d[0]):\n",
    "        o = (10**((len(d[1])-len(d[0]))))\n",
    "        d2[0]=o*int(d[0])\n",
    "        p = len(d[1])\n",
    "    else:\n",
    "        p = len(d[0])\n",
    "    # Re-write with same decimal places as int\n",
    "    d=d2\n",
    "    del d2\n",
    "    AA =  Bitwise_add(int(c[0]),int(c[1])) + ( Bitwise_add(int(d[0]),int(d[1])) / ( 10 ** p ) )\n",
    "    return AA\n",
    "\n",
    "n1=1.502851\n",
    "n2=1.12\n",
    "AdditionByHand( n1, n2 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 2.622851\n"
     ]
    }
   ],
   "source": [
    "# Algorithm for Addition (AA)\n",
    "# a primary school - Addition by hand -method\n",
    "\n",
    "n1=1.502851\n",
    "n2=1.12\n",
    "\n",
    "vector=[]\n",
    "residual=0\n",
    "#Split decimals\n",
    "#\n",
    "a=SplitFloat(n1);b=SplitFloat(n2)\n",
    "# Decimal Part Working\n",
    "#\n",
    "Decimals = RegularizeFractionalPartLengh( SplitInt(a[1]), SplitInt(b[1]) )\n",
    "Decimals[0].reverse()\n",
    "Decimals[1].reverse()\n",
    "for i in range(len(Decimals[1])):\n",
    "    SumD = Bitwise_add( Bitwise_add( Decimals[0][i], Decimals[1][i] ), residual )\n",
    "    if SumD > 10:\n",
    "        TemporalResidue =  int(list(str(SumD)[:-1])[0] )\n",
    "        #print(TemporalResidue)\n",
    "        residual = int((SumD - TemporalResidue)/10)\n",
    "        SumD = TemporalResidue\n",
    "    else:\n",
    "        residual = 0\n",
    "        SumD = SumD\n",
    "    vector.append(str(SumD))\n",
    "vector.reverse()\n",
    "DecimalPart = ''.join(vector)\n",
    "# return decimal Part\n",
    "#\n",
    "# print(DecimalPart,residual)\n",
    "\n",
    "# Integer Part Working\n",
    "Addition = float(Bitwise_add( Bitwise_add( int(a[0]), int(b[0]) ), residual ))+float('0'+'.'+DecimalPart)\n",
    "print('\\n', Addition )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subtraction\n",
    "- teaches to find the difference between numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 31 - 2\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bitwise_Subtract: -2\n"
     ]
    }
   ],
   "source": [
    "# Bitwise Int Subtraction\n",
    "x=1\n",
    "y=3\n",
    "# Bitwise Int Addition\n",
    "def Bitwise_Subtract(x,y):\n",
    "    c=1\n",
    "    if (x<y): x, y, c = y, x, -1 #We need swap values because the bitwise op only works on positive int\n",
    "    else: None\n",
    "    while y != 0:\n",
    "        get=(~x)&y #Get a bit\n",
    "        x = x ^ y #Get the difference\n",
    "        y = get << 1 # shift one bit borrow\n",
    "        #Return the process until be 0\n",
    "    else: return x*c\n",
    "#\n",
    "print('Bitwise_Subtract: '+str(Bitwise_Subtract(1,3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*let's start to explain:*\n",
    "\n",
    "- one in binary: 1 \n",
    "- Three: 11 \n",
    "\n",
    "Bitwise operators:\n",
    "\n",
    "| AND (&) | XOR (^) | NOT (~) | Shift Left Operator (<<) |\n",
    "| --------------- | --------------- | --------------- | --------------- |\n",
    "| 0 & 0 = 0 | 0 & 0 = 0 | Short: reverse bit order | Short: add a 0 at end |\n",
    "| 0 & 1 = 0 | 0 & 1 = 1 |  |  |\n",
    "| 1 & 0 = 1 | 1 & 0 = 1 |  |  |\n",
    "| 1 & 1 = 1 | 1 & 1 = 0 |  |  |\n",
    "\n",
    "sum(1,3):\n",
    "    while y != 0\n",
    "\n",
    "Then x : ~1 == 1\n",
    "\n",
    "Then get : 1 & 11 == 1\n",
    "\n",
    "And x : 1 ^ 11 == 10\n",
    "\n",
    "And y : 1 << 1 == 10\n",
    "\n",
    "Other loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A primary school - subtraction by hand -method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.382851"
      ]
     },
     "execution_count": 433,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a primary school - Subtraction by hand -method\n",
    "\n",
    "def Subtractionbyhand(n1,n2):\n",
    "    c=[];d=[]\n",
    "    #Split decimals\n",
    "    a=str(n1).split('.');b=str(n2).split('.')\n",
    "    #Populate lists\n",
    "    c.append(a[0]);c.append(b[0])\n",
    "    d.append(a[1]);d.append(b[1])\n",
    "    # Determine the largest decimal places\n",
    "    d2 = d.copy()\n",
    "    if len(d[0]) > len(d[1]):\n",
    "        o = (10**((len(d[0])-len(d[1]))))\n",
    "        d2[1]=o*int(d[1])\n",
    "        p = len(d[0])\n",
    "    elif len(d[1]) > len(d[0]):\n",
    "        o = (10**((len(d[1])-len(d[0]))))\n",
    "        d2[0]=o*int(d[0])\n",
    "        p = len(d[1])\n",
    "    else:\n",
    "        p = len(d[0])\n",
    "    # Re-write with same decimal places as int\n",
    "    d=d2\n",
    "    del d2\n",
    "    AAS =  Bitwise_Subtract(int(c[0]),int(c[1])) + ( Bitwise_Subtract(int(d[0]),int(d[1])) / ( 10 ** p ) )\n",
    "    return AAS\n",
    "\n",
    "n1=1.502851\n",
    "n2=1.12\n",
    "Subtractionbyhand( n1, n2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.382851\n"
     ]
    }
   ],
   "source": [
    "# Algorithm for Subtraction (AA)\n",
    "# a primary school - Subtraction by hand -method\n",
    "\n",
    "n1=1.502851\n",
    "n2=1.12\n",
    "\n",
    "vector=[]\n",
    "residual=0\n",
    "#Split decimals\n",
    "#\n",
    "a=SplitFloat(n1);b=SplitFloat(n2)\n",
    "# Decimal Part Working\n",
    "#\n",
    "Decimals = RegularizeFractionalPartLengh( SplitInt(a[1]), SplitInt(b[1]) )\n",
    "Decimals[0].reverse()\n",
    "Decimals[1].reverse()\n",
    "for i in range(len(Decimals[1])):\n",
    "    SumD = Bitwise_Subtract( Bitwise_Subtract( Decimals[0][i], residual ), Decimals[1][i] )\n",
    "    #print(SumD)\n",
    "    if (SumD > 0) or (SumD == 0):\n",
    "        SumD2 = SumD\n",
    "        residual = 0\n",
    "    else:\n",
    "        SumD2 = abs(Bitwise_Subtract(10, abs(SumD)))\n",
    "        del SumD\n",
    "        residual = 1\n",
    "        #print(SumD,'\\n')\n",
    "    vector.append(str(SumD2))\n",
    "vector.reverse()\n",
    "# return decimal Part\n",
    "#\n",
    "DecimalPart = ''.join(vector)\n",
    "# Integer Part Working\n",
    "#\n",
    "integer = Bitwise_Subtract( Bitwise_Subtract( int(a[0]), int(b[0]) ),residual)\n",
    "Subtraction = float(str(integer)+'.'+str(DecimalPart))\n",
    "print(Subtraction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiplication\n",
    "\n",
    "- "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Egiptian Method**\n",
    "\n",
    "Makes no sense to me, because at the end we need multiply 'big numbers'. Extends the procedure to < 10 number, meka more afordable to make by hand. but this the procedure that see in the web"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "171\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Working Process\n",
    "'''\n",
    "# find the max\n",
    "Numbers=[57,3]\n",
    "MajorNumber = GetMajorNum( Numbers[0], Numbers[1] )\n",
    "MinorNumber = GetMinorNum( Numbers[0], Numbers[1] )\n",
    "# find the list of powers\n",
    "# in this step - i can image that like mechanic tables for the refrigeration in ancient world,\n",
    "# commonly the technicians dont calculate - only find the value in the table\n",
    "# Very primitive, yeah... Remember the Bitwise_add?\n",
    "#\n",
    "# f(n) = 2 ** n\n",
    "#\n",
    "def GetPowOf2(a):\n",
    "    List = []; n = 1 # Declarations\n",
    "    Keys = []\n",
    "    for i in range( a ):\n",
    "        #if i == 0: None\n",
    "        #else:\n",
    "        exp = 2 ** (i+1)\n",
    "        if exp < a:\n",
    "            List.append( exp )\n",
    "            Keys.append( i+1 )\n",
    "        else: None\n",
    "    List.reverse()\n",
    "    Keys.reverse()\n",
    "    PowerOf2List = dict()\n",
    "    for i in range(len(List)):\n",
    "        PowerOf2List[Keys[i]]=List[i]\n",
    "    return PowerOf2List\n",
    "#\n",
    "MajorListPows = GetPowOf2( MajorNumber )\n",
    "MinorListPows = GetPowOf2( MinorNumber )\n",
    "\n",
    "# Decompose\n",
    "# Now decompose the values and find the factors in the table, this is the characteristic of this method -\n",
    "# only need make sums of the values in the table. in this case the first element is the max pow2 value\n",
    "#\n",
    "def DecomposeNumber(MajorNumber, MajorListPows):\n",
    "    vector={}\n",
    "    Residual = MajorNumber\n",
    "    for i in GetRange(list(MajorListPows.keys())):\n",
    "        if list(MajorListPows.values())[i] <= Residual:\n",
    "            vector[ list(MajorListPows.keys())[i] ] = list(MajorListPows.values())[i]\n",
    "            Residual = Residual-list(MajorListPows.values())[i]\n",
    "        #elif MajorNumber - sum(vector.values()) == 1:\n",
    "        else: None\n",
    "        #print(Residual)\n",
    "    if Residual < 4: vector[ 'rs' ] = Residual\n",
    "    return list(vector.values())\n",
    "def AncientEgiptMult(a,b):\n",
    "    Major = DecomposeNumber(MajorNumber, MajorListPows)\n",
    "    Minor = DecomposeNumber(MinorNumber, MinorListPows)\n",
    "    sum = 0\n",
    "    for EachMinor in Minor:\n",
    "        for EachMajor in Major:\n",
    "            sum = sum + (EachMinor * EachMajor)\n",
    "    return sum\n",
    "\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A primary school - Multiplication by hand -method**\n",
    "\n",
    "Curiously is more precise than the standard python process 0_o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 653,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.1\n"
     ]
    }
   ],
   "source": [
    "# Algorithm for Multiplication (AM)\n",
    "# a primary school - Multiplication by hand -method\n",
    "\n",
    "n1=1.10\n",
    "n2=11\n",
    "\n",
    "vector=[];sum = 0;k=0\n",
    "#Split decimals\n",
    "#\n",
    "a=SplitFloat(float(n1));b=SplitFloat(float(n2))\n",
    "PointCount = len(a[1])+len(b[1])\n",
    "# Now with the distance of the point multiply a long number ommiting the decimal point\n",
    "Fulla = (a[0]+a[1])\n",
    "Fullb = (b[0]+b[1])\n",
    "if n1 > n2:\n",
    "    fa=list(reversed(Fullb))\n",
    "    fb=list(reversed(Fulla))\n",
    "else:\n",
    "    fa=list(reversed(Fulla))\n",
    "    fb=list(reversed(Fullb))\n",
    "for i in fa:\n",
    "    renglon = []\n",
    "    for j in fb:\n",
    "        Operation = int(i)*int(j)\n",
    "        renglon.append( Operation )\n",
    "    renglon = list(reversed(renglon))\n",
    "    for m in range(k):\n",
    "        renglon.append(0)\n",
    "    k = k+1\n",
    "    vector.append( str(renglon).replace('[','').replace(']','').replace(',','').replace(' ','') )\n",
    "for each in range(len(vector)):\n",
    "    if each == 0: sum = int(vector[each])\n",
    "    else:\n",
    "        sum = int(vector[each]) + sum\n",
    "sum = sum / ( 10 ** PointCount )\n",
    "print(sum)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 654,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.100000000000001 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "n1=1.10\n",
    "n2=11\n",
    "print(n1*n2,'\\n')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13",
   "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.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "fe62ebc081bdf60ac8bf8a6932b5b68ec481c4dc8e3124191c9ec93641958169"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}