Merge 1.2.0 Development

Use rounding instead of format;
Rounding using Decimals for better performance;
Docstring;
Trigonometric errors propagation;
Remove numpy soft depend;
Accept any Iterable for list type argument;
Precision Tests;
Interface Tests;
Structure Tests;
Typings, docstrings and refactor;

Author: hlouzada

labfis/__init__.py

@@ -3,8 +3,9 @@
 # Copyright © 2020 labfis.py
 # (see LICENSE for details)
 
-__version__ = '1.1.7'
+__version__ = "1.2.0"
 
 # Local imports
-from labfis.uncertainty import labfloat
-labfloat
+from labfis.uncertainty import labfloat, Infix
+
+u = Infix(lambda x, y: labfloat(x, y))

labfis/test/__init__.py

@@ -4,35 +4,33 @@
 from math import sqrt
 import labfis
 
-dx = 1e-10
+dx = 1e-8
 
 
 def labfloat_iterative(vardic, exp):
     resulterror = 0
 
     for var in vardic.keys():
-        exec(var + "=" + "{0:.16f}".format(vardic[var][0]))
+        exec(var + "=" + "vardic[var][0]")
 
     for var in vardic.keys():
         var_value = vardic[var][0]
         var_error = vardic[var][1]
 
-        exec(var + "=" + "{0:.16f}".format(var_value) +
-             "+" + "{0:.16f}".format(dx))
+        exec(var + "=" + "var_value" + "+" + "dx")
         dph = eval(exp)
 
-        exec(var + "=" + "{0:.16f}".format(var_value))
+        exec(var + "=" + "var_value")
         dpn = eval(exp)
 
-        derivative = (dph - dpn)/dx
-        resulterror += (derivative * var_error) ** 2
+        derivative = (dph - dpn) / dx
+        resulterror += (derivative ** 2) * (var_error ** 2)
     return sqrt(resulterror)
 
 
 def labfloat_calc(vardic, exp):
     for var in vardic.keys():
-        exec(var + "=" +
-             "labfis.labfloat({0:.16f},{1:.16f})".format(*vardic[var]))
+        exec(var + "=" + "labfis.labfloat(vardic[var][0],vardic[var][1])")
     result = eval(exp)
     return result.uncertainty
 
@@ -46,27 +44,29 @@ def labfloat_calc(vardic, exp):
     "b": (rng.random(), rng.random()),
     "c": (rng.random(), rng.random()),
     "d": (rng.random(), rng.random()),
-    "e": (rng.random(), rng.random())
+    "e": (rng.random(), rng.random()),
 }
 
 
 def test_labfloat_expressions():
     print(vals)
     var = list(vals.keys())
-    opers = itertools.combinations_with_replacement(operations, len(var)-1)
+    opers = itertools.combinations_with_replacement(operations, len(var) - 1)
     for exp in opers:
         expression = ""
         for i in range(len(exp)):
-            if i == len(exp)-1:
-                expression += var[i]+exp[i]+var[i+1]
+            if i == len(exp) - 1:
+                expression += var[i] + exp[i] + var[i + 1]
             else:
-                expression += var[i]+exp[i]
+                expression += var[i] + exp[i]
 
         result1 = labfloat_iterative(vals, expression)
         result2 = labfloat_calc(vals, expression)
 
+        error = abs(result2 - result1) / result2
+
         print(expression)
-        print(result1, result2)
-        print(round(result1), round(result2))
+        print(type(result1), type(result2))
+        print("numerical: {}".format(result1), "analitical: {}".format(result2))
 
-        assert round(result2) == round(result1)
+        assert error < 1e-5

tests/test_labfloat.py renamed to labfis/test/accuracy_test.py

@@ -0,0 +1,46 @@
+from itertools import combinations
+from labfis import labfloat
+
+
+def test_zeros():
+    zeros = [
+        labfloat(),
+        labfloat(0),
+        labfloat(0.0),
+        labfloat(0, 0),
+        labfloat(0.0, 0.0),
+        labfloat(0.0, 0),
+        labfloat(0, 0.0),
+    ]
+
+    for z1, z2 in combinations(zeros, 2):
+        print(z1, z2)
+        assert list(z1) == list(z2)
+
+
+def test_indexing():
+    assert labfloat(10, 2)[:] == (10, 2)
+
+
+def TestUnary():
+    def test_pos():
+        x = labfloat(100, 4)
+        y = +x
+
+        assert list(x) == list(y)
+
+    def test_neg_mean():
+        x = labfloat(243, 2)
+        y = labfloat(-243, 2)
+        y = -y
+
+        assert list(x) == list(y)
+
+    def test_neg_uncertainty():
+        x = labfloat(243, 2)
+        y = labfloat(243, -2)
+
+        assert list(x) == list(y)
+
+
+# TODO: test cases for other arithmetic operators

labfis/test/arithmetic_test.py

@@ -0,0 +1,13 @@
+from random import uniform
+from labfis import u, labfloat
+
+
+def test_infix():
+    for _ in range(200):
+        x, e = uniform(-2e50, 2e50), uniform(-2e50, 2e50)
+        assert labfloat(x, e) == x | u | e == x << u >> e
+
+
+def test_attrs():
+    x = labfloat(10, 1)
+    assert x.mean == 10 and x.uncertainty == 1