def test_dot_shape_exception(): '''Dot product with wrong inner dimensions should raise exception.''' a = blaze.ones(blaze.dshape('20, 20, float64')) b = blaze.ones(blaze.dshape('30, 30, float64')) with assert_raises(ValueError): out = dot(a, b, outname=None)
def test_dot_not2d_exception(): '''Dot product of arrays other than 2D should raise exception.''' a = blaze.ones(blaze.dshape('20, 20, 20, float64')) b = blaze.ones(blaze.dshape('20, 20, 20, float64')) with assert_raises(ValueError): out = dot(a, b, outname=None)
def test_dot_out_exception(): '''Output array of wrong size should raise exception.''' a = blaze.ones(blaze.dshape('20, 20, float64')) b = blaze.ones(blaze.dshape('20, 30, float64')) out = blaze.zeros(blaze.dshape('20, 20, float64')) with assert_raises(ValueError): dot(a, b, out=out)
def test_dtw(): data = ones(dshape('100, float32')) query = ones(dshape('100, float32')) loc, dist = ucr.dtw(data, query, 0.1, 100, verbose=False) # these are stupid, mostly just to check for regressions assert isinstance(loc, int) assert isinstance(dist, float)
def test_dot(): '''Test of 2D dot product''' a = blaze.ones(blaze.dshape('20, 20, float64')) b = blaze.ones(blaze.dshape('20, 30, float64')) # Do not write output array to disk out = dot(a, b, outname=None) expected_ds = blaze.dshape('20, 30, float64') assert out.datashape._equal(expected_ds) # FIXME: Slow, but no other way to do this with Array API implemented so far for row in out: for elem in row: assert abs(elem - 20.0) < 1e-8
def test_metadata_has_prop(): a = blaze.ones(blaze.dshape('20, 20, float64')) c = blaze.NDTable([(1.0, 1.0), (1.0, 1.0)], dshape='2, {x: int32; y: float32}') assert blaze.metadata.has_prop(a, blaze.metadata.arraylike) assert blaze.metadata.has_prop(c, blaze.metadata.tablelike) assert not blaze.metadata.has_prop(a, blaze.metadata.tablelike)
def test_metadata_all_prop(): a = blaze.ones(blaze.dshape('20, 20, float64')) b = blaze.zeros(blaze.dshape('20, 20, float64')) c = blaze.NDTable([(1.0, 1.0), (1.0, 1.0)], dshape='2, {x: int32; y: float32}') assert blaze.metadata.all_prop((a, b), blaze.metadata.arraylike) assert not blaze.metadata.all_prop((a, b, c), blaze.metadata.arraylike)
def test_wrong_open_mode(self): ddesc = HDF5_DDesc(path=self.file, datapath='/earray', mode='w') a = blaze.ones('10 * float64', ddesc=ddesc) # Re-open the dataset ddesc = HDF5_DDesc(path=self.file, datapath='/earray', mode='r') self.assertTrue(ddesc.mode == 'r') a2 = blaze.array(ddesc) self.assertRaises(tb.FileModeError, append, a2, [1])
def test_wrong_open_mode(self): ddesc = BLZ_DDesc(path=self.rootdir, mode='w') a = blaze.ones('10 * float64', ddesc=ddesc) # Re-open the dataset ddesc = BLZ_DDesc(path=self.rootdir, mode='r') self.assertTrue(ddesc.mode == 'r') a2 = blaze.array(ddesc) self.assertRaises(IOError, append, a2, [1])
def test_open(self): persist = blaze.Persist(self.rooturi) a = blaze.ones('0, float64', persist=persist) a.append(range(10)) # Re-open the dataset in URI a2 = blaze.open(persist) self.assert_(isinstance(a2, blaze.Array)) self.assertEqual(dd_as_py(a2._data), list(range(10)))
def test_open(self): persist = blaze.Storage(self.rooturi, format="blz") a = blaze.ones('0 * float64', storage=persist) append(a,range(10)) # Re-open the dataset in URI a2 = blaze.open(persist) self.assertTrue(isinstance(a2, blaze.Array)) self.assertEqual(dd_as_py(a2._data), list(range(10)))
def test_open(self): ddesc = BLZ_DDesc(path=self.rootdir, mode='w') self.assertTrue(ddesc.mode == 'w') a = blaze.ones('0 * float64', ddesc=ddesc) append(a,range(10)) # Re-open the dataset ddesc = BLZ_DDesc(path=self.rootdir, mode='r') self.assertTrue(ddesc.mode == 'r') a2 = blaze.array(ddesc) self.assertTrue(isinstance(a2, blaze.Array)) self.assertEqual(ddesc_as_py(a2.ddesc), list(range(10)))
def test_open(self): ddesc = BLZ_DDesc(path=self.rootdir, mode='w') self.assertTrue(ddesc.mode == 'w') a = blaze.ones('0 * float64', ddesc=ddesc) append(a, range(10)) # Re-open the dataset ddesc = BLZ_DDesc(path=self.rootdir, mode='r') self.assertTrue(ddesc.mode == 'r') a2 = blaze.array(ddesc) self.assertTrue(isinstance(a2, blaze.Array)) self.assertEqual(ddesc_as_py(a2.ddesc), list(range(10)))
def test_open(self): ddesc = HDF5_DDesc(path=self.file, datapath='/earray', mode='a') self.assertTrue(ddesc.mode == 'a') a = blaze.ones('0 * float64', ddesc=ddesc) append(a, range(10)) # Re-open the dataset in URI ddesc = HDF5_DDesc(path=self.file, datapath='/earray', mode='r') self.assertTrue(ddesc.mode == 'r') a2 = blaze.array(ddesc) self.assertTrue(isinstance(a2, blaze.Array)) self.assertEqual(ddesc_as_py(a2.ddesc), list(range(10)))
def test_open(self): ddesc = HDF5_DDesc(path=self.file, datapath='/earray', mode='a') self.assertTrue(ddesc.mode == 'a') a = blaze.ones('0 * float64', ddesc=ddesc) append(a,range(10)) # Re-open the dataset in URI ddesc = HDF5_DDesc(path=self.file, datapath='/earray', mode='r') self.assertTrue(ddesc.mode == 'r') a2 = blaze.array(ddesc) self.assertTrue(isinstance(a2, blaze.Array)) self.assertEqual(ddesc_as_py(a2.ddesc), list(range(10)))
def test_ones(self): for t in self.full_types: a = ones(t) self.assertEqual(a.datashape, dshape(t))
def _create_persistent_array(name, dshape): print 'creating ' + name + '...' blaze.ones(dshape, params=blaze.params(storage=name, clevel=0))
def test_create_compress_ones(self): # A compressed array (backed by BLZ) a = blaze.ones('10 * int64', caps={'compress': True}) self.assertTrue(isinstance(a, blaze.Array)) self.assertEqual(dd_as_py(a._data), [1]*10)
def test_create_ones(self): # A default array a = blaze.ones('10 * int64') self.assertTrue(isinstance(a, blaze.Array)) self.assertEqual(dd_as_py(a._data), [1]*10)
# collection can be omitted. If that's the case, the dimensions will # be inferred. The following is thus equivalent: f = blaze.array([1, 2, 3], dshape='float32') print(f) # -------------------------------------------------------------------- print_section('Alternative constructors') # Arrays can be created to be all zeros: g = blaze.zeros('10 * 10 * int32') print(g) # All ones h = blaze.ones('10 * 10 * float64') print(h) # -------------------------------------------------------------------- print_section('Indexing') print_section('Indexing for read', level=1) print ('starting with a 4d array') array4d = blaze.ones('10 * 10 * 10 * 10 * float32') def describe_array(label, array): print(label) print('dshape: ', array.dshape) print(array)
def test_create_compress_ones(self): # A compressed array (backed by BLZ) ddesc = BLZ_DDesc(mode='w', bparams=blz.bparams(clevel=5)) a = blaze.ones('10 * int64', ddesc=ddesc) self.assertTrue(isinstance(a, blaze.Array)) self.assertEqual(list(a), [1]*10)
# Script for benchmarking OOC matrix matrix multiplication (only 2D supported) import shutil, os.path from time import time import blaze from linalg import dot # Remove pre-existent data directories for d in ('a', 'b', 'out'): if os.path.exists(d): shutil.rmtree(d) # Create simple inputs t0 = time() a = blaze.ones(blaze.dshape('2000, 2000, float64'), params=blaze.params(storage='a')) print "Time for matrix a creation : ", round(time()-t0, 3) t0 = time() b = blaze.ones(blaze.dshape('2000, 3000, float64'), params=blaze.params(storage='b')) print "Time for matrix b creation : ", round(time()-t0, 3) # Do the dot product t0 = time() out = dot(a, b, outname='out') print "Time for ooc matmul : ", round(time()-t0, 3) print "out:", out
def test_ones(): from blaze import ones, params a = ones('10, float64', params=params(clevel=5))
def test_create_ones(self): # A default array (backed by NumPy) a = blaze.ones('10, int64') self.assert_(isinstance(a, blaze.Array)) self.assertEqual(dd_as_py(a._data), [1]*10)
def test_create_compress_ones(self): # A compressed array (backed by BLZ) ddesc = BLZ_DDesc(mode='w', bparams=blz.bparams(clevel=5)) a = blaze.ones('10 * int64', ddesc=ddesc) self.assertTrue(isinstance(a, blaze.Array)) self.assertEqual(list(a), [1] * 10)
def make_test_array(datashape): return blaze.ones(datashape) * randint(1, 10)
from blaze import ones from blaze.rts import execute from blaze.compile import compile, explain A = ones('100, 100, int32') B = ones('100, 100, int32') expr = (A + B) * B # Normally we just use expr.eval() but to demonstrate the compile # pipeline... plan = compile(expr) print explain(plan) print execute(plan)
# collection can be omitted. If that's the case, the dimensions will # be inferred. The following is thus equivalent: f = blaze.array([ 1, 2, 3], dshape='float32') print(f) # -------------------------------------------------------------------- print_section('Alternative constructors') # Arrays can be created to be all zeros: g = blaze.zeros('10, 10, int32') print(g) # All ones h = blaze.ones('10, 10, float64') print(h) # -------------------------------------------------------------------- print_section('Indexing') print_section('Indexing for read', level=1) print ('starting with a 4d array') array4d = blaze.ones('10,10,10,10, float32') def describe_array(label, array): print(label) print('dshape: ', array.dshape) print(array)
from blaze import manifest, delayed, ones from blaze.rts import execute from blaze.compile import compile, explain A = ones('100, 100, int32', eclass=delayed) B = ones('100, 100, int32', eclass=delayed) expr = (A + B) * B # Normally we just use expr.eval() but to demonstrate the compile # pipeline... plan = compile(expr) print plan print explain(plan) print execute(plan)
# collection can be omitted. If that's the case, the dimensions will # be inferred. The following is thus equivalent: f = blaze.array([1, 2, 3], dshape='float32') print(f) # -------------------------------------------------------------------- print_section('Alternative constructors') # Arrays can be created to be all zeros: g = blaze.zeros('10, 10, int32') print(g) # All ones h = blaze.ones('10, 10, float64') print(h) # -------------------------------------------------------------------- print_section('Indexing') print_section('Indexing for read', level=1) print('starting with a 4d array') array4d = blaze.ones('10,10,10,10, float32') def describe_array(label, array): print(label) print('dshape: ', array.dshape) print(array)
# Script for benchmarking OOC matrix matrix multiplication (only 2D supported) import shutil, os.path from time import time import blaze from linalg import dot # Remove pre-existent data directories for d in ('a', 'b', 'out'): if os.path.exists(d): shutil.rmtree(d) # Create simple inputs t0 = time() a = blaze.ones(blaze.dshape('2000, 2000, float64'), params=blaze.params(storage='a')) print "Time for matrix a creation : ", round(time() - t0, 3) t0 = time() b = blaze.ones(blaze.dshape('2000, 3000, float64'), params=blaze.params(storage='b')) print "Time for matrix b creation : ", round(time() - t0, 3) # Do the dot product t0 = time() out = dot(a, b, outname='out') print "Time for ooc matmul : ", round(time() - t0, 3) print "out:", out