src/bdmconv.py

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

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

@@ -1,14 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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}")