Merge pull request QInfer#117 from ihincks/feature-product-domain

Feature: ProductDomain

Author: cgranade

doc/source/apiref/domains.rst

@@ -32,6 +32,16 @@ Class Reference
 .. autoclass:: Domain
     :members:
 
+
+:class:`ProductDomain` - Cartesian product of multiple domains
+--------------------------------------------------------------
+
+Class Reference 
+~~~~~~~~~~~~~~~
+.. autoclass:: ProductDomain
+    :members:
+
+    
 :class:`RealDomain` - (A subset of) Real Numbers
 ------------------------------------------------
 
@@ -58,4 +68,4 @@ This domain is used by :class:`MultinomialModel`.
 Class Reference 
 ~~~~~~~~~~~~~~~
 .. autoclass:: MultinomialDomain
-    :members:
+    :members:

src/qinfer/domains.py

@@ -30,11 +30,14 @@
 
 from builtins import range
 from future.utils import with_metaclass
+from functools import reduce
 
+from operator import mul
 from scipy.special import binom
 from math import factorial
-from itertools import combinations_with_replacement
+from itertools import combinations_with_replacement, product
 import numpy as np
+from .utils import join_struct_arrays, separate_struct_array
 
 import abc
 
@@ -44,6 +47,7 @@
 
 __all__ = [
     'Domain',
+    'ProductDomain',
     'RealDomain',
     'IntegerDomain',
     'MultinomialDomain'
@@ -145,6 +149,149 @@ def in_domain(self, points):
         """
         pass
 
+class ProductDomain(Domain):
+    """
+    A domain made from the cartesian product of other domains.
+
+    :param Domain domains: ``Domain`` instances as separate arguments, 
+        or as a singe list of ``Domain`` instances.
+    """
+    def __init__(self, *domains):
+        
+        if len(domains) == 1:
+            try:
+                self._domains = list(domains[0])
+            except:
+                self._domains = domains
+        else:
+            self._domains = domains
+        
+        self._domains = domains
+        self._dtypes = [domain.example_point.dtype for domain in self._domains]
+        self._example_point = join_struct_arrays(
+            [np.array(domain.example_point) for domain in self._domains]
+        )
+        self._dtype = self._example_point.dtype
+
+    @property
+    def is_continuous(self):
+        """
+        Whether or not the domain has an uncountable number of values.
+
+        :type: `bool`
+        """
+        return any([domain.is_continuous for domain in self._domains])
+
+    @property
+    def is_finite(self):
+        """
+        Whether or not the domain contains a finite number of points.
+
+        :type: `bool`
+        """
+        return all([domain.is_finite for domain in self._domains])
+
+    @property
+    def dtype(self):
+        """
+        The numpy dtype of a single element of the domain.
+
+        :type: `np.dtype`
+        """
+        return self._dtype
+
+    @property
+    def n_members(self):
+        """
+        Returns the number of members in the domain if it
+        `is_finite`, otherwise, returns `np.inf`.
+
+        :type: ``int`` or ``np.inf``
+        """
+        if self.is_finite:
+            return reduce(mul, [domain.n_members for domain in self._domains], 1)
+        else:
+            return np.inf
+
+    @property
+    def example_point(self):
+        """
+        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 self._example_point
+
+    @property
+    def values(self):
+        """
+        Returns an `np.array` of type `dtype` containing
+        some values from the domain.
+        For domains where `is_finite` is ``True``, all elements
+        of the domain will be yielded exactly once.
+
+        :rtype: `np.ndarray`
+        """
+        separate_values = [domain.values for domain in self._domains]
+        return np.concatenate([
+            join_struct_arrays(list(map(np.array, value))) 
+            for value in product(*separate_values)
+        ])
+
+    ## METHODS ##
+    
+    def _mytype(self, array):
+        # astype does weird stuff with struct names, and possibly 
+        # depends on numpy version; hopefully 
+        # the following is a bit more predictable since it passes through 
+        # uint8
+        return separate_struct_array(array, self.dtype)[0]
+    
+    def to_regular_arrays(self, array):
+        """
+        Expands from an array of type `self.dtype` into a list of
+        arrays with dtypes corresponding to the factor domains.
+
+        :param np.ndarray array: An `np.array` of type `self.dtype`.
+
+        :rtype: ``list``
+        """
+        return separate_struct_array(self._mytype(array), self._dtypes)
+
+    def from_regular_arrays(self, arrays):
+        """
+        Merges a list of arrays (of the same shape) of dtypes 
+        corresponding to the factor domains into a single array 
+        with the dtype of the ``ProductDomain``.
+
+        :param list array: A list with each element of type ``np.ndarray``
+
+        :rtype: `np.ndarray`
+        """
+        return self._mytype(join_struct_arrays([
+            array.astype(dtype)
+            for dtype, array in zip(self._dtypes, arrays)
+        ]))
+        
+
+    def in_domain(self, points):
+        """
+        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 all([
+            domain.in_domain(array)
+            for domain, array in
+                zip(self._domains, separate_struct_array(points, self._dtypes))
+        ])
+
+
 ## CLASSES ###################################################################
 
 class RealDomain(Domain):

src/qinfer/tests/test_domains.py

@@ -40,7 +40,8 @@
 )
 import abc
 from qinfer import (
-    Domain, RealDomain, IntegerDomain, MultinomialDomain
+    Domain, ProductDomain,
+    RealDomain, IntegerDomain, MultinomialDomain
 )
 
 import unittest
@@ -175,3 +176,97 @@ def test_array_conversion(self):
         assert_equal(self.domain.from_regular_array(arr2), arr1)
         assert_equal(self.domain.to_regular_array(self.domain.from_regular_array(arr2)), arr2)
         assert_equal(self.domain.from_regular_array(self.domain.to_regular_array(arr1)), arr1)
+        
+        
+class TestIntegerIntegerProductDomain(ConcreteDomainTest, DerandomizedTestCase):
+    """
+    Tests ProductDomain([IntegerDomain, IntegerDomain])
+    """
+    
+    def instantiate_domain(self):
+        return ProductDomain(
+            IntegerDomain(min=0,max=5), 
+            IntegerDomain(min=-2, max=2)
+        )
+    def instantiate_good_values(self):
+        return [
+            np.array([(0,0)], dtype=[('','<i8'),('','<i8')]),
+            np.array([(5,2),(0,-2)], dtype=[('','<i8'),('','<i8')])
+        ]
+    def instantiate_bad_values(self):
+        return [
+            np.array([(0.5,0)], dtype=[('','f8'),('','<i8')]),
+            np.array([(6,2),(0,-2)], dtype=[('','<i8'),('','<i8')])
+        ]
+
+    def test_array_conversion(self):
+        arr1 = np.array([(5,2),(0,-1)], dtype=[('','<i8'),('','<i8')])
+        arr2 = [np.array([5,0]), np.array([2,-1])]
+
+        assert_equal(self.domain.to_regular_arrays(arr1), arr2)
+        assert_equal(self.domain.from_regular_arrays(arr2), arr1)
+        assert_equal(self.domain.to_regular_arrays(self.domain.from_regular_arrays(arr2)), arr2)
+        assert_equal(self.domain.from_regular_arrays(self.domain.to_regular_arrays(arr1)), arr1)
+
+    #override
+    def test_is_finite(self):
+        assert(self.domain.is_finite)
+        assert(self.domain.is_discrete)
+
+class TestIntegerIntegerProductDomain2(ConcreteDomainTest, DerandomizedTestCase):
+    """
+    Tests ProductDomain([IntegerDomain, IntegerDomain])
+    """
+    
+    def instantiate_domain(self):
+        return ProductDomain(
+            IntegerDomain(min=0,max=5), 
+            IntegerDomain(min=-2, max=np.inf),
+            IntegerDomain(min=-np.inf, max=np.inf)
+        )
+    def instantiate_good_values(self):
+        return [
+            np.array([(0,0,0)], dtype=[('','<i8'),('','<i8'),('','<i8')]),
+            np.array([(5,2,0),(0,-2,10)], dtype=[('','<i8'),('','<i8'),('','<i8')])
+        ]
+    def instantiate_bad_values(self):
+        return [
+            np.array([(0.5,0,10)], dtype=[('','f8'),('','<i8'),('','<i8')]),
+            np.array([(6,2,10),(0,-2,10)], dtype=[('','<i8'),('','<i8'),('','<i8')])
+        ]
+        
+    #override
+    def test_is_finite(self):
+        assert(not self.domain.is_finite)
+        assert(self.domain.is_discrete)
+    
+class TestIntegerMultinomialProductDomain(ConcreteDomainTest, DerandomizedTestCase):
+    """
+    Tests ProductDomain([IntegerDomain, IntegerDomain])
+    """
+    
+    def instantiate_domain(self):
+        return ProductDomain(
+            IntegerDomain(min=0,max=5), 
+            MultinomialDomain(5, n_elements=3)
+        )
+    def instantiate_good_values(self):
+        return [
+            np.array([(0,[1,2,2])], dtype=[('','<i8'),('','<i8', 3)]),
+            np.array([(5,[5,0,0]),(0,[1,0,4])], dtype=[('','<i8'),('','<i8', 3)])
+        ]
+    def instantiate_bad_values(self):
+        return [
+            np.array([(-10,[1,2,2])], dtype=[('','<i8'),('k','<i8', 3)]),
+            np.array([(5,[-1,6,0]),(0,[1,0,4])], dtype=[('','<i8'),('k','<i8', 3)])
+        ]
+
+    def test_array_conversion(self):
+        arr1 = np.array([(5,[1,2,2]),(0,[5,0,0])], dtype=[('','<i8'),('k','<i8', 3)])
+        arr2 = [np.array([5,0]), np.array([([1,2,2],), ([5,0,0],)], dtype=[('k','<i8',3)])]
+
+        assert_equal(self.domain.to_regular_arrays(arr1), arr2)
+        assert_equal(self.domain.from_regular_arrays(arr2), arr1)
+        assert_equal(self.domain.to_regular_arrays(self.domain.from_regular_arrays(arr2)), arr2)
+        assert_equal(self.domain.from_regular_arrays(self.domain.to_regular_arrays(arr1)), arr1)
+    

src/qinfer/utils.py

@@ -462,6 +462,48 @@ def pretty_time(secs, force_h=False, force_m=False):
 def safe_shape(arr, idx=0, default=1):
     shape = np.shape(arr)
     return shape[idx] if idx < len(shape) else default
+    
+def join_struct_arrays(arrays):
+    """
+    Takes a list of possibly structured arrays, concatenates their
+    dtypes, and returns one big array with that dtype. Does the 
+    inverse of ``separate_struct_array``.
+    
+    :param list arrays: List of ``np.ndarray``s
+    """
+    # taken from http://stackoverflow.com/questions/5355744/numpy-joining-structured-arrays
+    sizes = np.array([a.itemsize for a in arrays])
+    offsets = np.r_[0, sizes.cumsum()]
+    shape = arrays[0].shape
+    joint = np.empty(shape + (offsets[-1],), dtype=np.uint8)
+    for a, size, offset in zip(arrays, sizes, offsets):
+        joint[...,offset:offset+size] = np.atleast_1d(a).view(np.uint8).reshape(shape + (size,))
+    dtype = sum((a.dtype.descr for a in arrays), [])
+    return joint.ravel().view(dtype)
+    
+def separate_struct_array(array, dtypes):
+    """
+    Takes an array with a structured dtype, and separates it out into 
+    a list of arrays with dtypes coming from the input ``dtypes``.
+    Does the inverse of ``join_struct_arrays``.
+    
+    :param np.ndarray array: Structured array.
+    :param dtypes: List of ``np.dtype``, or just a ``np.dtype`` and the number of
+        them is figured out automatically by counting bytes.
+    """
+    try:
+        offsets = np.cumsum([np.dtype(dtype).itemsize for dtype in dtypes])
+    except TypeError:
+        dtype_size = np.dtype(dtypes).itemsize
+        num_fields = int(array.nbytes / (array.size * dtype_size))
+        offsets = np.cumsum([dtype_size] * num_fields)
+        dtypes = [dtypes] * num_fields
+    offsets = np.concatenate([[0], offsets]).astype(int)
+    uint_array = array.view(np.uint8).reshape(array.shape + (-1,))
+    return [
+        uint_array[..., offsets[idx]:offsets[idx+1]].flatten().view(dtype)
+        for idx, dtype in enumerate(dtypes)
+    ]
 
 def sqrtm_psd(A, est_error=True, check_finite=True):
     """