Merge pull request #115 from ihincks/feature-domain-tests

Tests for Domains

Author: ihincks

setup.cfg

@@ -4,7 +4,7 @@ description-file = README.rst
 [bdist_wheel]
 universal = 1
 
-[pytest]
+[tool:pytest]
 python_files=tests/*.py
 python_classes=Test
 python_functions=*_test

src/qinfer/domains.py

@@ -90,18 +90,18 @@ def dtype(self):
     @abc.abstractproperty
     def n_members(self):
         """
-        Returns the number of members in the domain if it 
+        Returns the number of members in the domain if it
         `is_finite`, otherwise, returns `np.inf`.
 
-        :type: ``int`` or ``np.inf`` 
+        :type: ``int`` or ``np.inf``
         """
         pass
 
     @abc.abstractproperty
     def example_point(self):
         """
-        Returns any single point guaranteed to be in the domain, but 
-        no other guarantees; useful for testing purposes. 
+        Returns any single point guaranteed to be in the domain, but
+        no other guarantees; useful for testing purposes.
         This is given as a size 1 ``np.array`` of type `dtype`.
 
         :type: ``np.ndarray``
@@ -111,9 +111,9 @@ def example_point(self):
     @abc.abstractproperty
     def values(self):
         """
-        Returns an `np.array` of type `dtype` containing 
+        Returns an `np.array` of type `dtype` containing
         some values from the domain.
-        For domains where `is_finite` is ``True``, all elements 
+        For domains where `is_finite` is ``True``, all elements
         of the domain will be yielded exactly once.
 
         :rtype: `np.ndarray`
@@ -136,7 +136,7 @@ def is_discrete(self):
     @abc.abstractmethod
     def in_domain(self, points):
         """
-        Returns ``True`` if all of the given points are in the domain, 
+        Returns ``True`` if all of the given points are in the domain,
         ``False`` otherwise.
 
         :param np.ndarray points: An `np.ndarray` of type `self.dtype`.
@@ -149,13 +149,13 @@ def in_domain(self, points):
 
 class RealDomain(Domain):
     """
-    A domain specifying a contiguous (and possibly open ended) subset 
+    A domain specifying a contiguous (and possibly open ended) subset
     of the real numbers.
 
-    :param float min: A number specifying the lowest possible value of the 
+    :param float min: A number specifying the lowest possible value of the
+        domain.
+    :param float max: A number specifying the largest possible value of the
         domain.
-    :param float max: A number specifying the largest possible value of the 
-        domain. 
     """
 
     def __init__(self, min=-np.inf, max=np.inf):
@@ -167,20 +167,20 @@ def __init__(self, min=-np.inf, max=np.inf):
     @property
     def min(self):
         """
-        Returns the minimum value of the domain. 
+        Returns the minimum value of the domain.
 
         :rtype: `float`
         """
         return self._min
     @property
     def max(self):
         """
-        Returns the maximum value of the domain. 
+        Returns the maximum value of the domain.
 
         :rtype: `float`
         """
         return self._max
-    
+
     @property
     def is_continuous(self):
         """
@@ -211,7 +211,7 @@ def dtype(self):
     @property
     def n_members(self):
         """
-        Returns the number of members in the domain if it 
+        Returns the number of members in the domain if it
         `is_finite`, otherwise, returns `None`.
 
         :type: ``np.inf``
@@ -221,8 +221,8 @@ def n_members(self):
     @property
     def example_point(self):
         """
-        Returns any single point guaranteed to be in the domain, but 
-        no other guarantees; useful for testing purposes. 
+        Returns any single point guaranteed to be in the domain, but
+        no other guarantees; useful for testing purposes.
         This is given as a size 1 ``np.array`` of type ``dtype``.
 
         :type: ``np.ndarray``
@@ -237,9 +237,9 @@ def example_point(self):
     @property
     def values(self):
         """
-        Returns an `np.array` of type `self.dtype` containing 
+        Returns an `np.array` of type `self.dtype` containing
         some values from the domain.
-        For domains where ``is_finite`` is ``True``, all elements 
+        For domains where ``is_finite`` is ``True``, all elements
         of the domain will be yielded exactly once.
 
         :rtype: `np.ndarray`
@@ -250,27 +250,32 @@ def values(self):
 
     def in_domain(self, points):
         """
-        Returns ``True`` if all of the given points are in the domain, 
+        Returns ``True`` if all of the given points are in the domain,
         ``False`` otherwise.
 
         :param np.ndarray points: An `np.ndarray` of type `self.dtype`.
 
         :rtype: `bool`
         """
-        return np.all(points >= self._min) and np.all(points <= self._max)
+        if np.all(np.isreal(points)):
+            are_greater = np.all(np.greater_equal(points, self._min))
+            are_smaller = np.all(np.less_equal(points, self._max))
+            return  are_greater and are_smaller
+        else:
+            return False
 
 class IntegerDomain(Domain):
     """
-    A domain specifying a contiguous (and possibly open ended) subset 
-    of the integers. 
+    A domain specifying a contiguous (and possibly open ended) subset
+    of the integers.
 
-    Internally minimum and maximum are represented as 
+    Internally minimum and maximum are represented as
     floats in order to handle the case of infinite maximum, and minimums. The
-    integer conversion function will be applied to the min and max values. 
+    integer conversion function will be applied to the min and max values.
 
-    :param int min: A number specifying the lowest possible value of the 
-        domain.  
-    :param int max: A number specifying the largest possible value of the 
+    :param int min: A number specifying the lowest possible value of the
+        domain.
+    :param int max: A number specifying the largest possible value of the
         domain.
 
     Note: Yes, it is slightly unpythonic to specify `max` instead of `max`+1.
@@ -285,20 +290,20 @@ def __init__(self, min=0, max=np.inf):
     @property
     def min(self):
         """
-        Returns the minimum value of the domain. 
+        Returns the minimum value of the domain.
 
         :rtype: `float` or `np.inf`
         """
-        return int(self._min) if not np.isinf(self._min) else self._min  
+        return int(self._min) if not np.isinf(self._min) else self._min
     @property
     def max(self):
         """
-        Returns the maximum value of the domain. 
+        Returns the maximum value of the domain.
 
         :rtype: `float` or `np.inf`
         """
         return int(self._max) if not np.isinf(self._max) else self._max
-    
+
 
     @property
     def is_continuous(self):
@@ -330,7 +335,7 @@ def dtype(self):
     @property
     def n_members(self):
         """
-        Returns the number of members in the domain if it 
+        Returns the number of members in the domain if it
         `is_finite`, otherwise, returns `np.inf`.
 
         :type: ``int`` or ``np.inf``
@@ -343,8 +348,8 @@ def n_members(self):
     @property
     def example_point(self):
         """
-        Returns any single point guaranteed to be in the domain, but 
-        no other guarantees; useful for testing purposes. 
+        Returns any single point guaranteed to be in the domain, but
+        no other guarantees; useful for testing purposes.
         This is given as a size 1 ``np.array`` of type ``dtype``.
 
         :type: ``np.ndarray``
@@ -359,9 +364,9 @@ def example_point(self):
     @property
     def values(self):
         """
-        Returns an `np.array` of type `self.dtype` containing 
+        Returns an `np.array` of type `self.dtype` containing
         some values from the domain.
-        For domains where ``is_finite`` is ``True``, all elements 
+        For domains where ``is_finite`` is ``True``, all elements
         of the domain will be yielded exactly once.
 
         :rtype: `np.ndarray`
@@ -375,26 +380,31 @@ def values(self):
 
     def in_domain(self, points):
         """
-        Returns ``True`` if all of the given points are in the domain, 
+        Returns ``True`` if all of the given points are in the domain,
         ``False`` otherwise.
 
         :param np.ndarray points: An `np.ndarray` of type `self.dtype`.
 
         :rtype: `bool`
         """
-        are_integer = np.all(np.mod(points,1) == 0)
-        are_greater = np.all(points >= self._min) 
-        are_smaller = np.all(points <= self._max)
-        return  are_integer and are_greater and are_smaller
-    
+        if np.all(np.isreal(points)):
+            try:
+                are_integer = np.all(np.mod(points, 1) == 0)
+            except TypeError:
+                are_integer = False
+            are_greater = np.all(np.greater_equal(points, self._min))
+            are_smaller = np.all(np.less_equal(points, self._max))
+            return  are_integer and are_greater and are_smaller
+        else:
+            return False
 
 class MultinomialDomain(Domain):
     """
-    A domain specifying k-tuples of non-negative integers which 
+    A domain specifying k-tuples of non-negative integers which
     sum to a specific value.
 
     :param int n_meas: The sum of any tuple in the domain.
-    :param int n_elements: The number of elements in a tuple. 
+    :param int n_elements: The number of elements in a tuple.
     """
 
     def __init__(self, n_meas, n_elements=2):
@@ -419,7 +429,7 @@ def n_elements(self):
         :rtype: `int`
         """
         return self._n_elements
-    
+
 
     @property
     def is_continuous(self):
@@ -451,7 +461,7 @@ def dtype(self):
     @property
     def n_members(self):
         """
-        Returns the number of members in the domain if it 
+        Returns the number of members in the domain if it
         `is_finite`, otherwise, returns `None`.
 
         :type: ``int``
@@ -461,20 +471,20 @@ def n_members(self):
     @property
     def example_point(self):
         """
-        Returns any single point guaranteed to be in the domain, but 
-        no other guarantees; useful for testing purposes. 
+        Returns any single point guaranteed to be in the domain, but
+        no other guarantees; useful for testing purposes.
         This is given as a size 1 ``np.array`` of type ``dtype``.
 
         :type: ``np.ndarray``
         """
-        return np.array([([self.n_meas] + [0] * (self.n_elements-1))], dtype=self.dtype)
+        return np.array([([self.n_meas] + [0] * (self.n_elements-1),)], dtype=self.dtype)
 
     @property
     def values(self):
         """
-        Returns an `np.array` of type `self.dtype` containing 
+        Returns an `np.array` of type `self.dtype` containing
         some values from the domain.
-        For domains where ``is_finite`` is ``True``, all elements 
+        For domains where ``is_finite`` is ``True``, all elements
         of the domain will be yielded exactly once.
 
         :rtype: `np.ndarray`
@@ -483,32 +493,32 @@ def values(self):
         # This code comes from Jared Goguen at http://stackoverflow.com/a/37712597/1082565
         partition_array = np.empty((self.n_members, self.n_elements), dtype=int)
         masks = np.identity(self.n_elements, dtype=int)
-        for i, c in enumerate(combinations_with_replacement(masks, self.n_meas)): 
+        for i, c in enumerate(combinations_with_replacement(masks, self.n_meas)):
             partition_array[i,:] = sum(c)
 
         # Convert to dtype before returning
         return self.from_regular_array(partition_array)
-        
+
     ## METHODS ##
 
     def to_regular_array(self, A):
         """
-        Converts from an array of type `self.dtype` to an array 
-        of type `int` with an additional index labeling the 
+        Converts from an array of type `self.dtype` to an array
+        of type `int` with an additional index labeling the
         tuple indeces.
 
         :param np.ndarray A: An `np.array` of type `self.dtype`.
 
         :rtype: `np.ndarray`
         """
-        # this could be a static method, but we choose to be consistent with 
+        # this could be a static method, but we choose to be consistent with
         # from_regular_array
         return A.view((int, len(A.dtype.names))).reshape(A.shape + (-1,))
 
     def from_regular_array(self, A):
         """
-        Converts from an array of type `int` where the last index 
-        is assumed to have length `self.n_elements` to an array 
+        Converts from an array of type `int` where the last index
+        is assumed to have length `self.n_elements` to an array
         of type `self.d_type` with one fewer index.
 
         :param np.ndarray A: An `np.array` of type `int`.
@@ -520,14 +530,14 @@ def from_regular_array(self, A):
 
     def in_domain(self, points):
         """
-        Returns ``True`` if all of the given points are in the domain, 
+        Returns ``True`` if all of the given points are in the domain,
         ``False`` otherwise.
 
         :param np.ndarray points: An `np.ndarray` of type `self.dtype`.
 
         :rtype: `bool`
         """
         array_view = self.to_regular_array(points)
-        return np.all(array_view >= 0) and np.all(np.sum(array_view, axis=-1) == self.n_meas)
-
-    
+        non_negative = np.all(np.greater_equal(array_view, 0))
+        correct_sum = np.all(np.sum(array_view, axis=-1) == self.n_meas)
+        return non_negative and correct_sum