Add hash function for AffineScalarFunc class

uncertainties/core.py

@@ -1756,6 +1756,19 @@ def __bool__(self):
 
     ########################################
 
+    def __hash__(self):
+        """
+        Calculates the hash for any AffineScalarFunc object.
+        The hash is calculated from the nominal_value, and the derivatives.
+
+        Returns:
+            int: The hash of this object
+        """
+
+        items = sorted(self.derivatives.items(), key= lambda x: id(x[0]))
+        ids, values = zip(*map(lambda item: (id(item[0]), item[1]), items))
+        return hash((self._nominal_value, tuple(ids), tuple(values)))
+
     # Uncertainties handling:
 
     def error_components(self):
@@ -2729,7 +2742,7 @@ def __init__(self, value, std_dev, tag=None):
         # differentiable functions: for instance, Variable(3, 0.1)/2
         # has a nominal value of 3/2 = 1, but a "shifted" value
         # of 3.1/2 = 1.55.
-        value = float(value)
+        self._nominal_value = float(value)
 
         # If the variable changes by dx, then the value of the affine
         # function that gives its value changes by 1*dx:
@@ -2739,7 +2752,7 @@ def __init__(self, value, std_dev, tag=None):
         # takes much more memory.  Thus, this implementation chooses
         # more cycles and a smaller memory footprint instead of no
         # cycles and a larger memory footprint.
-        super(Variable, self).__init__(value, LinearCombination({self: 1.}))
+        super(Variable, self).__init__(self._nominal_value, LinearCombination({self: 1.}))
 
         self.std_dev = std_dev  # Assignment through a Python property
 
@@ -2766,6 +2779,22 @@ def std_dev(self, std_dev):
 
         self._std_dev = float(std_dev)
 
+    def __hash__(self):
+        """
+        Calculates the hash for any Variable object.
+        This simply calls the __hash__ method of `AffineScalarFunc` in most cases.
+        During initialization, the `_linear_part` and `_nominal_value` attributes does not exist.
+        Because of that, the id returned in case this method is called during initialization.
+
+        Returns:
+            int: The hash of this object
+        """
+        # Otherwise, pickles loads does not work
+        if not hasattr(self, "_nominal_value"):
+            self._nominal_value = None
+
+        return hash((self._nominal_value, (id(self),), (1.,)))
+
     # The following method is overridden so that we can represent the tag:
     def __repr__(self):
 
@@ -2776,13 +2805,6 @@ def __repr__(self):
         else:
             return "< %s = %s >" % (self.tag, num_repr)
 
-    def __hash__(self):
-        # All Variable objects are by definition independent
-        # variables, so they never compare equal; therefore, their
-        # id() are allowed to differ
-        # (http://docs.python.org/reference/datamodel.html#object.__hash__):
-        return id(self)
-
     def __copy__(self):
         """
         Hook for the standard copy module.

uncertainties/test_uncertainties.py

@@ -30,7 +30,7 @@
 # Local modules
 
 import uncertainties.core as uncert_core
-from uncertainties.core import ufloat, AffineScalarFunc, ufloat_fromstr
+from uncertainties.core import ufloat, AffineScalarFunc, ufloat_fromstr, LinearCombination
 from uncertainties import umath
 
 # The following information is useful for making sure that the right
@@ -2338,3 +2338,40 @@ def test_correlated_values_correlation_mat():
         assert arrays_close(
             numpy.array(cov_mat),
             numpy.array(uncert_core.covariance_matrix([x2, y2, z2])))
+
+    def test_hash():
+        '''
+        Tests the invariance that if x==y, then hash(x)==hash(y)
+        '''
+
+        a = ufloat(1.23, 2.34)
+        b = ufloat(1.23, 2.34)
+
+        # nominal values and std_dev terms are equal, but...
+        assert a.n==b.n and a.s==b.s
+        # ...x and y are independent variables, therefore not equal as uncertain numbers
+        assert a != b
+        assert hash(a) != hash(b)
+
+        # order of calculation should be irrelevant
+        assert a + b == b + a
+        assert hash(a + b) == hash(b + a)
+
+        # the equation (2x+x)/3 is equal to the variable x, so...
+        assert ((2*a+a)/3)==a
+        # ...hash of the equation and the variable should be equal
+        assert hash((2*a+a)/3)==hash(a)
+
+        c = ufloat(1.23, 2.34)
+
+        # the values of the linear combination entries matter
+        x = AffineScalarFunc(1, LinearCombination({a:1, b:2, c:1}))
+        y = AffineScalarFunc(1, LinearCombination({a:1, b:2, c:2}))
+        assert x != y
+        assert hash(x) != hash(y)
+
+        # the order of linear combination values matter and should not lead to the same hash
+        x = AffineScalarFunc(1, LinearCombination({a:1, b:2}))
+        y = AffineScalarFunc(1, LinearCombination({a:2, b:1}))
+        assert x != y
+        assert hash(x) != hash(y)