Esempio n. 1
0
def unify_simple(a, b):
    """Unify two blaze types"""
    if isinstance(a, _strtypes):
        a = dshape(a)
    if isinstance(b, _strtypes):
        b = dshape(b)
    [res], _ = unify([(a, b)], [True])
    return res
Esempio n. 2
0
    def test_parsing2(self):
        t = dshape('Int[32]')
        self.assertEqual(len(t.parameters), 1)
        self.assertIsInstance(t.parameters[0], T.Fixed)

        t = dshape('Int[Float[32] -> Complex[64]]')
        self.assertEqual(len(t.parameters), 1)
        self.assertIsInstance(t.parameters[0], T.Function)
Esempio n. 3
0
def kernel(signature, impl='python', **metadata):
    """
    Define an blaze python-level kernel. Further implementations may be
    associated with this overloaded kernel using the 'implement' method.

    Parameters
    ----------
    signature: string or Type
        Optional function signature

    Usage
    -----

        @kernel
        def add(a, b):
            return a + b

    or

        @kernel('a -> a -> a') # All types are unified
        def add(a, b):
            return a + b
    """
    def decorator(f):
        func = lookup_previous(f)
        if isinstance(func, BlazeFunc):
            func = func.dispatcher
        elif isinstance(func, types.FunctionType):
            raise TypeError(
                "Function %s in current scope is not overloadable" % (func,))
        else:
            func = Dispatcher()

        dispatcher = overload(signature, func=func)(f)

        if isinstance(f, types.FunctionType):
            kernel = BlazeFunc(dispatcher)
        else:
            assert isinstance(f, BlazeFunc), f
            kernel = f

        metadata.setdefault('elementwise', True)
        kernel.add_metadata(metadata)
        if impl != 'python':
            kernel.implement(f, signature, impl, f)
        return kernel

    signature = dshape(signature)

    if not isinstance(signature, T.Mono):
        # @kernel
        # def f(...): ...
        f = signature
        signature = None
        return decorator(f)
    else:
        # @kernel('a -> a -> b')
        # def f(...): ...
        return decorator
    def test_var_dim(self):
        a = nd.array([[1,2,3], [4,5], [6]])
        dd = DyNDDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('3, var, int32'))
        self.assertEqual(dd_as_py(dd), [[1,2,3], [4,5], [6]])
        self.assertEqual(dd_as_py(dd[0]), [1,2,3])
        self.assertEqual(dd_as_py(dd[1]), [4,5])
        self.assertEqual(dd_as_py(dd[2]), [6])
Esempio n. 5
0
    def test_parsing(self):
        t = dshape('Int[X]')
        cls = type(t)

        self.assertIsInstance(cls, T.TypeConstructor)
        self.assertEqual(str(cls(32)), 'Int[32]')
        self.assertIsInstance(cls(32), cls)

        flags0 = t.flags[0]
        self.assertEqual(flags0, {'coercible': False})
    def test_descriptor_getitem_types(self):
        a = nd.array([[1, 2, 3], [4, 5, 6]])
        dd = DyNDDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('2, 3, int32'))
        # Indexing should produce DyNDDataDescriptor instances
        self.assertTrue(isinstance(dd[0], DyNDDataDescriptor))
        self.assertEqual(dd_as_py(dd[0]), [1,2,3])
        self.assertTrue(isinstance(dd[1,2], DyNDDataDescriptor))
        self.assertEqual(dd_as_py(dd[1,2]), 6)
Esempio n. 7
0
    def decorator(f, signature=signature):
        if signature is None:
            signature = dummy_signature(f)
        else:
            signature = dshape(signature)

        dispatcher = func or f.__globals__.get(f.__name__)
        dispatcher = dispatcher or Dispatcher()
        dispatcher.add_overload(f, signature, kwds)
        return dispatcher
    def test_element_iter_write_buffered(self):
        a = nd.array([1, 2, 3, 4, 5], access='rw').ucast(ndt.int64)
        dd = DyNDDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('5, int64'))
        with dd.element_write_iter() as ge:
            self.assertTrue(isinstance(ge, IElementWriteIter))
            for val, ptr in izip([5,7,4,5,3], ge):
                x = ctypes.c_int64(val)
                ctypes.memmove(ptr, ctypes.addressof(x), 8)
        self.assertEqual(dd_as_py(dd), [5,7,4,5,3])
    def test_element_iter_write(self):
        a = np.array([1, 2, 3, 4, 5], dtype=np.int32)
        dd = NumPyDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('5, int32'))
        with dd.element_write_iter() as ge:
            self.assertTrue(isinstance(ge, IElementWriteIter))
            for val, ptr in izip([5,7,4,5,3], ge):
                x = ctypes.c_int32(val)
                ctypes.memmove(ptr, ctypes.addressof(x), 4)
        self.assertEqual(dd_as_py(dd), [5,7,4,5,3])
 def test_record(self):
     class ctds(ctypes.Structure):
         _fields_ = [('a', ctypes.c_int8),
                     ('b', ctypes.c_double),
                     ('c', ctypes.c_uint8),
                     ('d', ctypes.c_uint16)]
     ds = datashape.dshape('{a: int8; b: float64; c: uint8; d: float16}')
     self.assertEqual(ds.c_itemsize, ctypes.sizeof(ctds))
     self.assertEqual(ds.c_alignment, ctypes.alignment(ctds))
     self.assertEqual(ds.c_offsets,
                     (ctds.a.offset, ctds.b.offset, ctds.c.offset, ctds.d.offset))
    def test_descriptor_iter_types(self):
        a = nd.array([[1, 2, 3], [4, 5, 6]])
        dd = DyNDDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('2, 3, int32'))
        # Iteration should produce DyNDDataDescriptor instances
        vals = []
        for el in dd:
            self.assertTrue(isinstance(el, DyNDDataDescriptor))
            self.assertTrue(isinstance(el, IDataDescriptor))
            vals.append(dd_as_py(el))
        self.assertEqual(vals, [[1, 2, 3], [4, 5, 6]])
    def test_element_iter_types(self):
        a = nd.array([[1, 2, 3], [4, 5, 6]])
        dd = DyNDDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('2, 3, int32'))
        # Requesting element iteration should produce an
        # IElementReadIter object
        ei = dd.element_read_iter()
        self.assertTrue(isinstance(ei, IElementReadIter))
        # Iteration over the IElementReadIter object should produce
        # raw ints which are pointers
        for ptr in ei:
            self.assertTrue(isinstance(ptr, _inttypes))
Esempio n. 13
0
 def test_array_subarray(self):
     self.assertEqual(datashape.dshape('3, int32').subarray(0),
                     datashape.dshape('3, int32'))
     self.assertEqual(datashape.dshape('3, int32').subarray(1),
                     datashape.int32)
     self.assertEqual(str(datashape.dshape('3, var, M, int32').subarray(2)),
                     str(datashape.dshape('M, int32')))
     self.assertEqual(str(datashape.dshape('3, var, M, float64').subarray(3)),
                     str(datashape.float64))
    def test_element_write(self):
        a = nd.array([1, 2, 3, 4, 5], access='rw')
        dd = DyNDDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('5, int32'))
        ge = dd.element_writer(1)
        self.assertTrue(isinstance(ge, IElementWriter))

        x = ctypes.c_int32(123)
        ge.write_single((1,), ctypes.addressof(x))
        self.assertEqual(dd_as_py(dd), [1,123,3,4,5])

        with ge.buffered_ptr((3,)) as dst_ptr:
            x = ctypes.c_int32(456)
            ctypes.memmove(dst_ptr, ctypes.addressof(x), 4)
        self.assertEqual(dd_as_py(dd), [1,123,3,456,5])
    def test_element_write_buffered(self):
        a = np.array([1, 2, 3, 4, 5], dtype=np.dtype(np.int32).newbyteorder())
        dd = NumPyDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('5, int32'))
        self.assertFalse(dd.npyarr.dtype.isnative)
        ge = dd.element_writer(1)
        self.assertTrue(isinstance(ge, IElementWriter))

        x = ctypes.c_int32(123)
        ge.write_single((1,), ctypes.addressof(x))
        self.assertEqual(dd_as_py(dd), [1,123,3,4,5])

        with ge.buffered_ptr((3,)) as dst_ptr:
            x = ctypes.c_int32(456)
            ctypes.memmove(dst_ptr, ctypes.addressof(x), 4)
        self.assertEqual(dd_as_py(dd), [1,123,3,456,5])
    def test_element_getitem_types(self):
        a = nd.array([[1, 2, 3], [4, 5, 6]])
        dd = DyNDDataDescriptor(a)

        self.assertEqual(dd.dshape, datashape.dshape('2, 3, int32'))
        # Requesting element_reader with one index should produce an
        # IElementReader object
        ge = dd.element_reader(1)
        self.assertTrue(isinstance(ge, IElementReader))
        # Iteration over the IElementReadIter object should produce
        # raw ints which are pointers
        self.assertTrue(isinstance(ge.read_single((1,)), _inttypes))

        # Requesting element reader with two indices should produce an
        # IElementReader object
        ge = dd.element_reader(2)
        self.assertTrue(isinstance(ge, IElementReader))
        # Iteration over the IElementReadIter object should produce
        # raw ints which are pointers
        self.assertTrue(isinstance(ge.read_single((1,2)), _inttypes))
 def test_array(self):
     ds = datashape.dshape('3, 5, 2, int32')
     self.assertEqual(ds.c_itemsize, 3 * 5 * 2 * 4)
     self.assertEqual(ds.c_alignment, datashape.int32.c_alignment)
     self.assertEqual(ds.c_strides, (40, 8, 4))
 def test_record_nolayout(self):
     ds = datashape.dshape('{a: int8; b: M, float32}')
     self.assertRaises(AttributeError, lambda x : x.c_itemsize, ds)
     self.assertRaises(AttributeError, lambda x : x.c_alignment, ds)
     self.assertRaises(AttributeError, lambda x : x.c_offsets, ds)
Esempio n. 19
0
def parse(s):
    if s[0].isupper() and re.match('\w+$', s): # HACK
        return TypeConstructor(s, 0, [])
    return dshape(s)
 def test_array_nolayout(self):
     # If the datashape has no layout, it should raise errors
     ds = datashape.dshape('3, 5, M, int32')
     self.assertRaises(AttributeError, lambda x : x.c_itemsize, ds)
     self.assertRaises(AttributeError, lambda x : x.c_alignment, ds)
     self.assertRaises(AttributeError, lambda x : x.c_strides, ds)
Esempio n. 21
0
 def test_dshape_compare(self):
     self.assertNotEqual(datashape.int32, datashape.dshape('1, int32'))