Major/core rewrite

tests/data/double_inputs.json

@@ -0,0 +1,86 @@
+{
+ "real": [
+  [
+   61.948769256033415,
+   70.5550954777836
+  ],
+  [
+   46.850712521157874,
+   -65.85302740822756
+  ],
+  [
+   -94.01945784686339,
+   53.2050384231714
+  ],
+  [
+   -1.8714783718018992,
+   -40.62274499568404
+  ],
+  [
+   55.48271966281476,
+   -59.66716850518983
+  ],
+  [
+   85.57625158786456,
+   18.923183930053142
+  ],
+  [
+   -25.543794819578864,
+   28.458901597667307
+  ],
+  [
+   -58.22572652851596,
+   -55.149994961379136
+  ],
+  [
+   19.7847891211907,
+   13.045151558451337
+  ],
+  [
+   -78.72099898638444,
+   29.78965840724598
+  ]
+ ],
+ "positive": [
+  [
+   39.62120657307086,
+   38.607310262495766
+  ],
+  [
+   54.33981543838278,
+   28.062652449376692
+  ],
+  [
+   17.743737673925896,
+   1.7777965570752063
+  ],
+  [
+   85.60124763154259,
+   50.30480800764012
+  ],
+  [
+   16.00414707453346,
+   7.824807251032462
+  ],
+  [
+   20.264307051880557,
+   8.596303854680299
+  ],
+  [
+   41.032040066580464,
+   52.56582126667049
+  ],
+  [
+   3.880748834752179,
+   68.13725191777147
+  ],
+  [
+   7.612002572953491,
+   59.60418726181359
+  ],
+  [
+   90.97870010384057,
+   77.57227867030959
+  ]
+ ]
+}

tests/data/gen_math_input.py

@@ -0,0 +1,35 @@
+import json
+import random
+
+
+valid_inputs_dict = {}
+
+
+def main():
+    num_reps = 10
+
+    single_inputs_dict = {
+        "real": [random.uniform(-100, 100) for _ in range(num_reps)],
+        "positive": [random.uniform(0, 100) for _ in range(num_reps)],
+        "minus_one_to_plus_one": [random.uniform(-1, +1) for _ in range(num_reps)],
+        "greater_than_one": [random.uniform(+1, 100) for _ in range(num_reps)],
+    }
+    with open("single_inputs.json", "w+") as f:
+        json.dump(single_inputs_dict, f, indent=True)
+
+    double_inputs_dict = {
+        "real": [
+            [random.uniform(-100, 100), random.uniform(-100, +100)]
+            for _ in range(num_reps)
+        ],
+        "positive": [
+            [random.uniform(0, 100), random.uniform(0, +100)]
+            for _ in range(num_reps)
+        ],
+    }
+    with open("double_inputs.json", "w+") as f:
+        json.dump(double_inputs_dict, f, indent=True)
+
+
+if __name__ == "__main__":
+    main()

tests/data/single_inputs.json

@@ -0,0 +1,50 @@
+{
+ "real": [
+  -36.60911685237882,
+  -54.04795785278229,
+  35.226273393828535,
+  16.722777334693546,
+  -55.5181324887325,
+  -62.49825495233803,
+  50.512955649849545,
+  -47.63011552984197,
+  90.78699381342642,
+  -72.40556773563449
+ ],
+ "positive": [
+  5.07297531068115,
+  64.62026513266443,
+  21.952976518206846,
+  90.61088865462847,
+  59.81071602890059,
+  46.17566226725043,
+  30.982963044884336,
+  5.6489912218142475,
+  97.59743784477794,
+  28.722096237490323
+ ],
+ "minus_one_to_plus_one": [
+  -0.9412686734683116,
+  0.3670101257679639,
+  -0.11887039329301285,
+  0.2205312239720758,
+  -0.9996974354519661,
+  0.9117325174017104,
+  -0.813521041155469,
+  0.8869249308007081,
+  0.9985145705229643,
+  -0.9749926023995483
+ ],
+ "greater_than_one": [
+  96.9308840672482,
+  31.44674643194246,
+  70.78595897202372,
+  7.181134117830289,
+  83.0726592694887,
+  73.19779748965216,
+  96.57319519176947,
+  32.9817245997553,
+  31.64207124559558,
+  71.43971257472222
+ ]
+}

tests/helpers.py

@@ -1,10 +1,20 @@
 import random
 from math import isnan, isinf
 
+from uncertainties.new import UFloat
 import uncertainties.core as uncert_core
 from uncertainties.core import ufloat, AffineScalarFunc
 
 
+def get_single_uatom_and_weight(uval: UFloat):
+    error_components = uval.error_components
+    if len(error_components) != 1:
+        raise ValueError("uval does not have exactly 1 UAtom.")
+    uatom = next(iter(error_components))
+    weight = error_components[uatom]
+    return uatom, weight
+
+
 def power_all_cases(op):
     """
     Checks all cases for the value and derivatives of power-like
@@ -163,7 +173,7 @@ def power_wrt_ref(op, ref_op):
 # Utilities for unit testing
 
 
-def numbers_close(x, y, tolerance=1e-6):
+def numbers_close(x, y, tolerance=1e-6, fractional=False):
     """
     Returns True if the given floats are close enough.
 
@@ -177,18 +187,19 @@ def numbers_close(x, y, tolerance=1e-6):
 
     # Instead of using a try and ZeroDivisionError, we do a test,
     # NaN could appear silently:
-
-    if x != 0 and y != 0:
-        if isinf(x):
-            return isinf(y)
-        elif isnan(x):
-            return isnan(y)
-        else:
-            # Symmetric form of the test:
-            return 2 * abs(x - y) / (abs(x) + abs(y)) < tolerance
-
-    else:  # Either x or y is zero
-        return abs(x or y) < tolerance
+    if isnan(x):
+        return isnan(y)
+    elif isinf(x):
+        return isinf(y) and (y > 0) is (x > 0)
+    elif x == 0:
+        return abs(y) < tolerance
+    elif y == 0:
+        return abs(x) < tolerance
+    else:
+        diff = abs(x - y)
+        if fractional:
+            diff = 2 * diff / (abs(x + y))
+        return diff < tolerance
 
 
 def ufloats_close(x, y, tolerance=1e-6):
@@ -200,11 +211,8 @@ def ufloats_close(x, y, tolerance=1e-6):
     The tolerance is applied to both the nominal value and the
     standard deviation of the difference between the numbers.
     """
-
     diff = x - y
-    return numbers_close(diff.nominal_value, 0, tolerance) and numbers_close(
-        diff.std_dev, 0, tolerance
-    )
+    return numbers_close(diff.n, 0) and numbers_close(diff.s, 0)
 
 
 class DerivativesDiffer(Exception):
@@ -360,34 +368,7 @@ def compare_derivatives(func, numerical_derivatives, num_args_list=None):
 else:
 
     def uarrays_close(m1, m2, precision=1e-4):
-        """
-        Returns True iff m1 and m2 are almost equal, where elements
-        can be either floats or AffineScalarFunc objects.
-
-        Two independent AffineScalarFunc objects are deemed equal if
-        both their nominal value and uncertainty are equal (up to the
-        given precision).
-
-        m1, m2 -- NumPy arrays.
-
-        precision -- precision passed through to
-        uncertainties.test_uncertainties.numbers_close().
-        """
-
-        # ! numpy.allclose() is similar to this function, but does not
-        # work on arrays that contain numbers with uncertainties, because
-        # of the isinf() function.
-
-        for elmt1, elmt2 in zip(m1.flat, m2.flat):
-            # For a simpler comparison, both elements are
-            # converted to AffineScalarFunc objects:
-            elmt1 = uncert_core.to_affine_scalar(elmt1)
-            elmt2 = uncert_core.to_affine_scalar(elmt2)
-
-            if not numbers_close(elmt1.nominal_value, elmt2.nominal_value, precision):
+        for v1, v2 in zip(m1, m2):
+            if not ufloats_close(v1, v2, tolerance=precision):
                 return False
-
-            if not numbers_close(elmt1.std_dev, elmt2.std_dev, precision):
-                return False
-
         return True

tests/new/data_gen.py

@@ -0,0 +1,24 @@
+import random
+
+
+from uncertainties.new.umath import float_funcs_dict
+
+
+no_other_list = [
+    "__abs__",
+    "__pos__",
+    "__neg__",
+    "__trunc__",
+]
+
+for func in float_funcs_dict:
+    vals = []
+    first = random.uniform(-2, +2)
+    vals.append(first)
+    if func not in no_other_list:
+        second = random.uniform(-2, +2)
+        vals.append(second)
+    vals = tuple(vals)
+    unc = random.uniform(-1, 1)
+
+    print(f"(\"{func}\", {vals}, {unc}),")

tests/new/numpy/test_covariance.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+from uncertainties.new import correlated_values, covariance_matrix, UArray
+
+
+mean_vals = [1, 2, 3]
+cov = np.array([
+    [1, 0.2, 0.3],
+    [0.2, 2, 0.2],
+    [0.3, 0.2, 4],
+])
+
+
+def test_covariance():
+    ufloats = correlated_values(mean_vals, cov)
+    np.testing.assert_array_equal(UArray(ufloats).nominal_value, np.array(mean_vals))
+    np.testing.assert_array_almost_equal(covariance_matrix(ufloats), cov)