add symlink to binary-to-decimal-mantice-converter.py to simplify library importing

src/bdmconv.py

@@ -0,0 +1 @@
+binary-to-decimal-mantice-converter.py

src/binary-to-decimal-mantice-converter.py

@@ -0,0 +1,14 @@
+def convert(x):
+    result = 0
+
+    for p, i in enumerate(x):
+        if i == '1':
+            result += 2**(-p-1)
+
+    return result
+
+# sample implementation
+if __name__ == "__main__":
+    x = input("Enter mantice: ")
+    r = convert(x)
+    print(f"Result: {r}")

src/bitutils.py

@@ -0,0 +1,59 @@
+def align_binary_to_right(value, size):
+    if "b" in value:
+        result = value.split("b")[1]
+    else:
+        result = str(value)
+
+    return result[-size:].rjust(size, "0")
+
+ar = align_binary_to_right
+
+def align_binary_to_left(value, size):
+    if "b" in value:
+        result = value.split("b")[1]
+    else:
+        result = str(value)
+
+    return result[-size:].ljust(size, "0")
+
+al = align_binary_to_left
+
+
+def shift_left(rg, fill_bit = 0):
+    return rg[1:] + fill_bit
+
+l = shift_left
+
+
+def shift_right(rg, fill_bit = 0):
+    return fill_bit + rg[:-1]
+
+r = shift_right
+
+
+def sum_supplementary_codes(x, y, size):
+    return al(bin(int("0b"+x, 2) + int("0b"+y, 2))[2:], size)
+
+sum = sum_supplementary_codes
+
+
+def sum_supplementary_codes_with_overspill(x, y, size):
+    result = bin(int("0b"+x, 2) + int("0b"+y, 2))[2:]
+    if len(result) > size:
+        return al(result, size), '1'
+    else:
+        return al(result, size), '0'
+
+sump = sum_supplementary_codes_with_overspill
+
+
+def invert_bit(b):
+    if b == '0':
+        return '1'
+    elif b == '1':
+        return '0'
+    else:
+        print(f"binutils: detected impossible call: inv({b})")
+        exit(1)
+
+inv = invert_bit

src/divide.py

@@ -0,0 +1,139 @@
+import bitutils as bu
+
+def divide(n, int_x, int_y, method):
+    if method == 1:
+        # getting binary values
+        x = bu.ar(bin(int_x)[2:], n)
+        y = bu.ar(bin(int_y)[2:], n)
+
+        # getting the supplementary code of X
+        y_inv = "".join([bu.inv(i) for i in y]) # invert
+        y_inv = bu.sum(y_inv, '1', n) # +1
+
+        # writing startup register values
+        # registers order: RG3, RG2, RG1
+        rg_table = [[['start', '1'*(n-1), x, y, '-'], ['start', '1'*(n-1), x, y_inv, '-']]]
+
+        # iterations counter
+        i = 0
+
+        while rg_table[-1][-1][1][0] != '0':
+            i += 1
+            rg_table.append([])
+
+            if rg_table[-2][-1][2][0] == '1':
+                rg_table[-1].append([
+                    i,
+                    rg_table[-2][-1][1], # copy previous value
+                    bu.sum(rg_table[-2][-1][2], rg_table[0][0][3], n), # RG2 := RG2 + RG1
+                    '-',
+                    "RG2 := RG2 + RG1"
+                ])
+            else:
+                rg_table[-1].append([
+                    i,
+                    rg_table[-2][-1][1], # copy previous value
+                    bu.sum(rg_table[-2][-1][2], rg_table[0][1][3], n), # RG2 := RG2 - RG1
+                    '-',
+                    "RG2 := RG2 - RG1"
+                ])
+
+            rg_table[-1].append([
+                i,
+                bu.l(rg_table[-1][-1][1], bu.inv(rg_table[-1][-1][2][0])),
+                bu.l(rg_table[-1][-1][2], '0'),
+                '-',
+                "l(RG3).RG2[n+2], l(RG2).0"
+            ])
+
+        return rg_table, rg_table[-1][-1][1][1:]
+
+    elif method == 2:
+        # getting binary values
+        x = '0' + bu.al(bin(int_x)[2:], 2*n)
+        y = '0' + bu.al(bin(int_y)[2:], 2*n)
+
+        # writing startup register values
+        # registers order: RG3, RG2, RG1
+        rg_table = [[['start', '1'*(n+1), x, y, '-']]]
+
+        # iterations counter
+        i = 0
+
+        while rg_table[-1][-1][1][0] != '0':
+            i += 1
+            rg_table.append([])
+
+            if rg_table[-2][-1][2][0] == '1':
+                new_rg2, p = bu.sump(rg_table[-2][-1][2], rg_table[-2][0][3], 2*n+1)
+                rg_table[-1].append([
+                    i,
+                    bu.l(rg_table[-2][-1][1], p), # l(RG3).SM(p)
+                    new_rg2, # RG2 := RG2 + RG1
+                    bu.r(rg_table[-2][0][3], '0'),
+                    "RG2 := RG2 + RG1\n" \
+                    "RG1 := 0.r(RG1)\n" \
+                    "RG3 := l(RG3).SM(p)"
+                ])
+            else:
+                y_sup = ''
+                invert = False
+                for r in rg_table[-2][0][3][::-1]:
+                    if invert:
+                        y_sup += bu.inv(r)
+                    else:
+                        y_sup += r
+
+                    if r == '1':
+                        invert = True
+
+                y_sup = y_sup[::-1]
+
+                new_rg2, p = bu.sump(rg_table[-2][-1][2], y_sup, 2*n+1)
+
+                rg_table[-1].append([
+                    i,
+                    bu.l(rg_table[-2][-1][1], p), # copy previous value
+                    new_rg2, # RG2 := RG2 - RG1
+                    bu.r(rg_table[-2][0][3], '0'),
+                    "RG2 := RG2 - !RG1 + D\n" \
+                    "RG1 := 0.r(RG1)\n" \
+                    "RG3 := l(RG3).SM(p)"
+                ])
+
+        return rg_table, rg_table[-1][-1][1][1:]
+
+
+if __name__ == "__main__":
+    # a fully functional reference
+    # implementation for this library
+    # is provided below
+
+    raw_x = input("X: ")
+    raw_y = input("Y: ")
+
+    if len(raw_x) == len(raw_y):
+        n = len(raw_x)
+    else:
+        n = int(input("n: "))
+
+    x = int("0b" + raw_x, 2)
+    y = int("0b" + raw_y, 2)
+
+    method = int(input("Method: "))
+
+    dt, result = divide(n, x, y, method)
+
+    from lib.prettytable import PrettyTable
+    pt = PrettyTable()
+    pt.field_names = ["Iteration", "RG3", "RG2", "RG1", "Operations"]
+
+    for i in dt:
+        for j in range(len(i)):
+            if j+1 == len(i):
+                pt.add_row(i[j], divider = True)
+            else:
+                pt.add_row(i[j])
+
+    print(pt)
+    print(f"Result: {result}")