Version 0.3

canbula · canbula · commit 6fcc9a642d6f · 2023-11-14T17:48:14.000+03:00
diff --git a/README.md b/README.md
@@ -5,15 +5,12 @@ ieee754 is a Python module which finds the IEEE-754 representation of a floating
 <li>Half Precision (16 bit: 1 bit for sign + 5 bits for exponent + 10 bits for mantissa)</li>
 <li>Single Precision (32 bit: 1 bit for sign + 8 bits for exponent + 23 bits for mantissa)</li>
 <li>Double Precision (64 bit: 1 bit for sign + 11 bits for exponent + 52 bits for mantissa)</li>
-<li>Quadrupole Precision (128 bit: 1 bit for sign + 15 bits for exponent + 112 bits for mantissa)</li>
+<li>Quadruple Precision (128 bit: 1 bit for sign + 15 bits for exponent + 112 bits for mantissa)</li>
 <li>Octuple Precision (256 bit: 1 bit for sign + 19 bits for exponent + 236 bits for mantissa)</li>
 
 ## Prerequisites
 
-ieee754 uses numpy, so you should install numpy first.
-```sh
-$ pip install numpy
-```
+ieee754 does not require any external libraries or modules.
 
 ## Installing
 
@@ -33,10 +30,13 @@ from ieee754 import IEEE754
 x = 13.375
 a = IEEE754(x)
 # you should call the instance as a string
+print(a)
 print(str(a))
 print(f"{a}")
 # you can get the hexadecimal presentation like this
-print(a.str2hex())
+print(a.hex())
+# you can get more detailed information like this
+print(a.json())
 ```
 
 ### Select a Precision
@@ -46,14 +46,27 @@ from ieee754 import IEEE754
 
 for p in range(5):
     a = IEEE754(x, p)
-    print("x = %f | b = %s | h = %s" % (13.375, a, a.str2hex()))
+    print("x = %f | b = %s | h = %s" % (13.375, a, a.hex()))
+```
+
+### Use the Precision Name as an Interface
+You can use the precision name as an interface to get the IEEE-754 representation of a floating point number. With this method you can get the IEEE-754 representation of a floating point number without creating an instance.
+```Python
+from ieee754 import half, single, double, quadruple, octuple
+
+x = 13.375
+print(half(x))
+print(single(x))
+print(double(x))
+print(quadruple(x))
+print(octuple(x))
 ```
 
 ### Using a Custom Precision
-You can force total length, exponent, and mantissa size, and also the bias.
+You can force exponent, and mantissa size by using force_exponent and force_mantissa parameters to create your own custom precision.
 ```Python
-a = IEEE754(x, force_length=19, force_exponent=6, force_mantissa=12, force_bias=31)
-print(f"{a}")
+a = IEEE754(x, force_exponent=6, force_mantissa=12)
+print(a)
 ```
 
 
diff --git a/ieee754/IEEE754.py b/ieee754/IEEE754.py
@@ -1,97 +1,214 @@
-import numpy as np
+from decimal import Decimal, getcontext
 
 
 class IEEE754:
-    def __init__(self, x, precision=2, 
-    force_length= None, force_exponent=None, force_mantissa=None, force_bias=None):
-        self.precision = precision
-        length_list = [16, 32, 64, 128, 256]
-        exponent_list = [5, 8, 11, 15, 19]
-        mantissa_list = [10, 23, 52, 112, 236]
-        bias_list = [15, 127, 1023, 16383, 262143]
-        if force_length is not None:
-            self.length = force_length
-        else:
-            self.length = length_list[precision]
-        if force_exponent is not None:
-            self.exponent = force_exponent
-        else:
-            self.exponent = exponent_list[precision]
-        if force_mantissa is not None:
-            self.mantissa = force_mantissa
-        else:
-            self.mantissa = mantissa_list[precision]
-        if force_bias is not None:
-            self.bias = force_bias
-        else:
-            self.bias = bias_list[precision]
-        self.s = 0 if x >= 0 else 1
-        x = abs(x)
-        self.x = x
-        self.i = self.integer2binary(int(x))
-        self.d = self.decimal2binary(x-int(x))
-        self.e = self.integer2binary((self.i.size-1)+self.bias)
-        self.m = np.append(self.i[1::], self.d)
-        self.h = ''
-
-    def __str__(self):
-        r = np.zeros(self.length, dtype=int)
-        i_d = np.append(self.i[1::], self.d)
-        r[0] = self.s
-        r[1+(self.exponent - self.e.size):(self.exponent + 1):] = self.e
-        r[(1 + self.exponent):(1 + self.exponent + i_d.size):] = i_d[0:self.mantissa]
-        s = np.array2string(r, separator='')
-        return s[1:-1].replace("\n", "").replace(" ", "")
+    def __init__(
+        self,
+        number: str = "0.0",
+        precision: int = 2,
+        force_exponent: int = None,
+        force_mantissa: int = None,
+    ) -> None:
+        getcontext().prec = 256
+        self.precision: int = precision
+        exponent_list: list[int] = [5, 8, 11, 15, 19]
+        mantissa_list: list[int] = [10, 23, 52, 112, 236]
+        self.__exponent: int = (
+            force_exponent
+            if force_exponent is not None
+            else exponent_list[self.precision]
+        )
+        self.__mantissa: int = (
+            force_mantissa
+            if force_mantissa is not None
+            else mantissa_list[self.precision]
+        )
+        self.__bias: int = 2 ** (self.__exponent - 1) - 1
+        self.__edge_case: str = None
+        self.number: Decimal = self.validate_number(number)
+        if self.__edge_case is None:
+            self.sign: str = self.find_sign()
+            self.__scale, self.number = self.scale_up_to_integer(self.number, 2)
+            self.binary: str = f"{self.number:b}"
+            self.binary_output: str = (
+                f"{self.binary[:-self.__scale]}.{self.binary[-self.__scale:]}"
+            )
+            self.exponent = self.find_exponent()
+            self.mantissa = self.find_mantissa()
+
+    def validate_number(self, number: str) -> Decimal:
+        if number == "":
+            number = "0.0"
+        if Decimal(number).is_infinite():
+            if Decimal(number) > 0:
+                # +inf: 0 11111111 00000000000000000000000
+                self.__edge_case = f"0 {'1' * self.__exponent} {'0' * self.__mantissa}"
+                return Decimal("Infinity")
+            # -inf: 1 11111111 00000000000000000000000
+            self.__edge_case = f"1 {'1' * self.__exponent} {'0' * self.__mantissa}"
+            return Decimal("-Infinity")
+        if Decimal(number).is_nan() and Decimal(number).is_snan():
+            # snan: 0 11111111 00000000000000000000001
+            self.__edge_case = (
+                f"0 {'1' * self.__exponent} {'0' * (self.__mantissa - 1)}1"
+            )
+            return Decimal("NaN")
+        if Decimal(number).is_nan() and Decimal(number).is_qnan():
+            # qnan: 0 11111111 10000000000000000000000
+            self.__edge_case = (
+                f"0 {'1' * self.__exponent} 1{'0' * (self.__mantissa - 1)}"
+            )
+            return Decimal("NaN")
+        if not number == number:
+            # nan: 0 11111111 11111111111111111111111
+            self.__edge_case = f"0 {'1' * self.__exponent} {'1' * self.__mantissa}"
+            return Decimal("NaN")
+        if Decimal(number) == 0:
+            if Decimal(number).is_signed():
+                # -0: 1 00000000 00000000000000000000000
+                self.__edge_case = f"1 {'0' * self.__exponent} {'0' * self.__mantissa}"
+            else:
+                # +0: 0 00000000 00000000000000000000000
+                self.__edge_case = f"0 {'0' * self.__exponent} {'0' * self.__mantissa}"
+            return Decimal("0")
+        if isinstance(number, int):
+            number = f"{number}.0"
+        if not isinstance(number, str):
+            number = str(number)
+        try:
+            number = Decimal(number)
+        except:
+            raise ValueError(f"Invalid number: {number}")
+        denormalized_range = self.calculate_denormalized_range(
+            self.__exponent, self.__mantissa
+        )
+        if Decimal(number) < Decimal(denormalized_range[0]):
+            raise ValueError(
+                f"Number is too small, must be larger than {denormalized_range[0]}, we lost both exponent and mantissa, please increase precision."
+            )
+        if Decimal(number) < Decimal(denormalized_range[1]):
+            raise ValueError(
+                f"Number is too small, must be larger than {denormalized_range[1]}, we lost exponent, please increase precision."
+            )
+        return number
+
+    @staticmethod
+    def calculate_denormalized_range(exponent_bits: int, mantissa_bits: int) -> tuple:
+        bias = 2 ** (exponent_bits - 1) - 1
+        smallest_normalized = 2 ** -(bias - 1)
+        smallest_denormalized = smallest_normalized * 2**-mantissa_bits
+        largest_denormalized = smallest_normalized - 2 ** -(bias + mantissa_bits - 1)
+
+        return (smallest_denormalized, largest_denormalized)
+
+    def find_sign(self) -> str:
+        if self.number < 0:
+            return "1"
+        return "0"
 
     @staticmethod
-    def integer2binary(x):
-        b = np.empty((0,), dtype=int)
-        while x > 1:
-            b = np.append(b, np.array([x % 2]))
-            x = int(x/2)
-        b = np.append(b, np.array([x]))
-        b = b[::-1]
-        return b
-
-    def decimal2binary(self, x):
-        b = np.empty((0,), dtype=int)
-        i = 0
-        while x > 0 and i < self.mantissa:
-            x = x * 2
-            b = np.append(b, np.array([int(x)]))
-            x -= int(x)
-            i += 1
-        return b
-
-    def str2hex(self):
-        s = str(self)
-        for i in range(0, len(s), 4):
-            ss = s[i:i+4]
+    def scale_up_to_integer(number: Decimal, base: int) -> (int, int):
+        scale = 0
+        while number != int(number):
+            number *= base
+            scale += 1
+        return scale, int(number)
+
+    def find_exponent(self) -> str:
+        exponent = len(self.binary) - 1 + self.__bias - self.__scale
+        # fill with leading zeros if necessary
+        return f"{exponent:0{self.__exponent}b}"
+
+    def find_mantissa(self) -> str:
+        # fill with trailing zeros if necessary
+        mantissa = f"{self.binary[1:]:<0{self.__mantissa}}"
+        if len(mantissa) > self.__mantissa:
+            # round up if mantissa is too long
+            mantissa = f"{mantissa[: self.__mantissa - 1]}1"
+        return mantissa
+
+    def __str__(self) -> str:
+        if self.__edge_case is not None:
+            return self.__edge_case
+        return f"{self.sign} {self.exponent} {self.mantissa}"
+
+    def hex(self) -> str:
+        h = ""
+        s = str(self).replace(" ", "")
+        limit = len(s) - (len(s) % 4)
+        for i in range(0, limit, 4):
+            ss = s[i : i + 4]
             si = 0
             for j in range(4):
-                si += int(ss[j]) * (2**(3-j))
+                si += int(ss[j]) * (2 ** (3 - j))
             sh = hex(si)
-            self.h += sh[2]
-        return self.h
+            h += sh[2]
+        return h.upper()
+
+    def json(self) -> dict:
+        return {
+            "exponent-bits": self.__exponent,
+            "mantissa-bits": self.__mantissa,
+            "bias": self.__bias,
+            "sign": self.sign,
+            "exponent": self.exponent,
+            "mantissa": self.mantissa,
+            "binary": self.binary,
+            "binary_output": self.binary_output,
+            "hex": self.hex(),
+            "up scaled number": self.number,
+            "scale": self.__scale,
+            "number": self.number / (2**self.__scale),
+        }
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+def half(x: str) -> IEEE754:
+    return IEEE754(x, 0)
+
+
+def single(x: str) -> IEEE754:
+    return IEEE754(x, 1)
+
+
+def double(x: str) -> IEEE754:
+    return IEEE754(x, 2)
+
+
+def quadruple(x: str) -> IEEE754:
+    return IEEE754(x, 3)
+
+
+def octuple(x: str) -> IEEE754:
+    return IEEE754(x, 4)
 
 
 if __name__ == "__main__":
     # with default options (Double Precision)
     x = 13.375
     a = IEEE754(x)
     # you should call the instance as a string
+    print(a)
     print(str(a))
     print(f"{a}")
     # you can get the hexadecimal presentation like this
-    print(a.str2hex())
-    # or you can specify a precision and
+    print(a.hex())
+    # or you can specify a precision
     for p in range(5):
         a = IEEE754(x, p)
-        print("x = %f | b = %s | h = %s" % (13.375, a, a.str2hex()))
+        print("x = %f | b = %s | h = %s" % (13.375, a, a.hex()))
     # or you can use your own custom precision
-    a = IEEE754(x, 
-    force_length=19, 
-    force_exponent=6, 
-    force_mantissa=12, 
-    force_bias=31)
+    a = IEEE754(x, force_exponent=6, force_mantissa=12)
     print(f"{a}")
+    # you can get more details with json
+    print(a.json())
+
+    # you can also call the precision functions
+    x = 13.375
+    print(half(x))
+    print(single(x))
+    print(double(x))
+    print(quadruple(x))
+    print(octuple(x))
diff --git a/ieee754/__init__.py b/ieee754/__init__.py
@@ -1 +1 @@
-from ieee754.IEEE754 import IEEE754
+from ieee754.IEEE754 import IEEE754
diff --git a/setup.py b/setup.py

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-from ieee754.IEEE754 import IEEE754`
	`1`	`+from ieee754.IEEE754 import IEEE754`