def test_simple(self): x = blaze.array([1+1j, 0+2j, 1+2j, blaze.inf, blaze.nan]) y_r = blaze.array([blaze.sqrt(2.), 2, blaze.sqrt(5), blaze.inf, blaze.nan]) y = blaze.abs(x) for i in range(len(x)): assert_almost_equal(y[i], y_r[i])
def test_power_complex(self): x = blaze.array([1+2j, 2+3j, 3+4j]) assert_equal(x**0, [1., 1., 1.]) assert_equal(x**1, x) assert_almost_equal(x**2, [-3+4j, -5+12j, -7+24j]) assert_almost_equal(x**3, [(1+2j)**3, (2+3j)**3, (3+4j)**3]) assert_almost_equal(x**4, [(1+2j)**4, (2+3j)**4, (3+4j)**4]) assert_almost_equal(x**(-1), [1/(1+2j), 1/(2+3j), 1/(3+4j)]) assert_almost_equal(x**(-2), [1/(1+2j)**2, 1/(2+3j)**2, 1/(3+4j)**2]) assert_almost_equal(x**(-3), [(-11+2j)/125, (-46-9j)/2197, (-117-44j)/15625]) assert_almost_equal(x**(0.5), [cmath.sqrt(1+2j), cmath.sqrt(2+3j), cmath.sqrt(3+4j)]) norm = 1./((x**14)[0]) assert_almost_equal(x**14 * norm, [i * norm for i in [-76443+16124j, 23161315+58317492j, 5583548873 + 2465133864j]]) def assert_complex_equal(x, y): assert_array_equal(x.real, y.real) assert_array_equal(x.imag, y.imag) for z in [complex(0, np.inf), complex(1, np.inf)]: z = blaze.array([z], dshape="complex[float64]") assert_complex_equal(z**1, z) assert_complex_equal(z**2, z*z) assert_complex_equal(z**3, z*z*z)
def test_bitwise_xor_bool(self): t = blaze.array(True) f = blaze.array(False) self.assertEqual(ddesc_as_py((t ^ t).ddesc), False) self.assertEqual(ddesc_as_py((t ^ f).ddesc), True) self.assertEqual(ddesc_as_py((f ^ t).ddesc), True) self.assertEqual(ddesc_as_py((f ^ f).ddesc), False)
def test_bitwise_and_bool(self): t = blaze.array(True) f = blaze.array(False) self.assertEqual(ddesc_as_py((t & t).ddesc), True) self.assertEqual(ddesc_as_py((t & f).ddesc), False) self.assertEqual(ddesc_as_py((f & t).ddesc), False) self.assertEqual(ddesc_as_py((f & f).ddesc), False)
def test_binary_kerneltree_lifted(self): # Create some simple blaze funcs, using Numba def _add(a,b): return a + b def _mul(a,b): return a * b add = BlazeFunc('add',[('f8(f8,f8)', _add), ('c16(c16,c16)', _add)]) mul = BlazeFunc('mul', {(double,)*3: _mul, (c128,)*3: _mul}) # Array data and expression af = blaze.array([[1,2,3], [4,5,6]],dshape=double) bf = blaze.array([2,3,4],dshape=double) cf = add(af,bf) df = mul(cf,cf) lifted_kernel = df._data.kerneltree.fuse().kernel.lift(1, 'C') ubck = lifted_kernel.unbound_single_ckernel # Allocate the result, and run the kernel across the arguments result = blaze.zeros(df.dshape) args = [arg.arr._data for arg in df._data.args] ck = ubck.bind(result._data, args) execute_expr_single(result._data, args, result._data.dshape.subarray(-2), [a.dshape.subarray(-2) for a in args], ck) self.assertEqual(dd_as_py(result._data), [[(a+b) * (a+b) for a, b in izip(a1, b1)] for a1, b1 in izip( [[1,2,3], [4,5,6]], [[2,3,4]]*2)])
def test_complex_nans(self): nan = blaze.nan for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]: arg1 = blaze.array([0, cnan, cnan]) arg2 = blaze.array([cnan, 0, cnan]) out = blaze.array([0, 0, nan], dshape=datashape.complex_float64) assert_equal(blaze.fmin(arg1, arg2), out)
def test_bitwise_or_bool(self): t = blaze.array(True) f = blaze.array(False) self.assertEqual(dd_as_py((t | t)._data), True) self.assertEqual(dd_as_py((t | f)._data), True) self.assertEqual(dd_as_py((f | t)._data), True) self.assertEqual(dd_as_py((f | f)._data), False)
def test_square(self): a = blaze.array([0., 3., 8., 1e10, math.sqrt(12345)]) b = blaze.array([0., 9., 64., 1e20, 12345]) result = blaze.square(a) assert_almost_equal(result, b) result = blaze.square(-a) assert_almost_equal(result, b)
def test_interp(self): a = array(range(10), dshape=dshape('10, int32')) b = array(range(10), dshape=dshape('10, float32')) expr = add(a, mul(a, b)) result = blaze.eval(expr, strategy='py') expected = blaze.array([ 0, 2, 6, 12, 20, 30, 42, 56, 72, 90]) self.assertEqual(type(result), blaze.Array) self.assertTrue(np.all(result == expected))
def test01(self): """Testing with only blaze arrays""" a, b = np.arange(self.N), np.arange(1, self.N+1) c = blaze.array(a) d = blaze.array(b) cr = blaze._elwise_eval("c * d", vm=self.vm) nr = a * b assert_array_equal(cr[:], nr, "eval does not work correctly")
def test01(self): """Testing elwise_eval() with blaze arrays and constants""" a, b = np.arange(self.N), np.arange(1, self.N+1) c = blaze.array(a, ddesc=self.ddesc1) d = blaze.array(b, ddesc=self.ddesc2) cr = blaze._elwise_eval("c * d + 1", vm=self.vm, ddesc=self.ddesc3) nr = a * b + 1 assert_array_equal(cr[:], nr, "eval does not work correctly")
def make_blaze(value): if not isinstance(value, blaze.Array): dshape = T.typeof(value) if not dshape.shape: value = blaze.array([value], dshape) else: value = blaze.array(value, dshape) return value
def test_log10_values(self): x = [1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10] y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for ds in ['float32', 'float64']: xf = blaze.array(x, dshape=ds) yf = blaze.array(y, dshape=ds) result = blaze.log10(xf) assert_almost_equal(result, yf)
def test_graph(self): a = array(np.arange(10), dshape=dshape('10, int32')) b = array(np.arange(10), dshape=dshape('10, float32')) expr = add(a, mul(a, b)) graph, ctx = expr.expr self.assertEqual(len(ctx.params), 2) self.assertFalse(ctx.constraints) self.assertEqual(graph.dshape, dshape('10, float64'))
def test_remainder_mod_int(self): a = blaze.array([-3, -2, -1, 0, 1, 2, 3]) a_mod_2 = blaze.array([1, 0, 1, 0, 1, 0, 1]) a_mod_3 = blaze.array([0, 1, 2, 0, 1, 2, 0]) assert_equal(blaze.remainder(a, 2), a_mod_2) assert_equal(blaze.mod(a, 2), a_mod_2) assert_equal(blaze.remainder(a, 3), a_mod_3) assert_equal(blaze.mod(a, 3), a_mod_3)
def test_nesting(self): myfunc = create_overloaded_add() # A little bit of nesting a = blaze.eval(myfunc(myfunc(blaze.array([3, 4]), blaze.array([1, 2])), blaze.array([2, 10]))) self.assertEqual(a.dshape, dshape('2 * int32')) self.assertEqual(nd.as_py(a.ddesc.dynd_arr()), [6, 16])
def test_remainder_mod_float(self): a = blaze.array([-3, -2, -1, 0, 1, 2, 3], dshape='float32') a_mod_2 = blaze.array([1, 0, 1, 0, 1, 0, 1], dshape='float32') a_mod_3 = blaze.array([0, 1, 2, 0, 1, 2, 0], dshape='float32') assert_equal(blaze.remainder(a, 2), a_mod_2) assert_equal(blaze.mod(a, 2), a_mod_2) assert_equal(blaze.remainder(a, 3), a_mod_3) assert_equal(blaze.mod(a, 3), a_mod_3)
def test_graph(self): a = array(nd.range(10, dtype=ndt.int32)) b = array(nd.range(10, dtype=ndt.float32)) expr = add(a, multiply(a, b)) graph, ctx = expr.expr self.assertEqual(len(ctx.params), 2) self.assertFalse(ctx.constraints) self.assertEqual(graph.dshape, dshape('10, float64'))
def test_exp2_values(self): x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for ds in ['float32', 'float64']: xf = blaze.array(x, dshape=ds) yf = blaze.array(y, dshape=ds) result = blaze.exp2(yf) assert_almost_equal(result, xf)
def test_add_with_pyobj(self): a = blaze.array(3) + 3 self.assertEqual(dd_as_py(a._data), 6) a = 3 + blaze.array(4) self.assertEqual(dd_as_py(a._data), 7) a = blaze.array([1, 2]) + 4 self.assertEqual(dd_as_py(a._data), [5, 6]) a = [1, 2] + blaze.array(5) self.assertEqual(dd_as_py(a._data), [6, 7])
def test_nesting_and_coercion(self): myfunc = create_overloaded_add() # More nesting, with conversions a = blaze.eval(myfunc(myfunc(blaze.array([1,2]), blaze.array([-2, 10])), myfunc(blaze.array([1, 5], dshape='int16'), blaze.array(3, dshape='int16')))) self.assertEqual(a.dshape, blaze.dshape('2, int32')) self.assertEqual(nd.as_py(a._data.dynd_arr()), [-3, 14])
def test01(self): """Testing elwise_eval() with blaze arrays and scalars""" a = np.arange(self.N*self.M).reshape(self.N, self.M) b = np.arange(1, self.N*self.M+1).reshape(self.N, self.M) c = blaze.array(a) d = blaze.array(b) cr = blaze._elwise_eval("c * d + 2", vm=self.vm) nr = a * b + 2 assert_array_equal(cr[:], nr, "eval does not work correctly")
def test00(self): """Testing elwise_eval() with only blaze arrays""" a = np.arange(self.N*self.M).reshape(self.N, self.M) b = np.arange(1, self.N*self.M+1).reshape(self.N, self.M) c = blaze.array(a, ddesc=self.ddesc1) d = blaze.array(b, ddesc=self.ddesc2) cr = blaze._elwise_eval("c * d", vm=self.vm, ddesc=self.ddesc3) nr = a * b assert_array_equal(cr[:], nr, "eval does not work correctly")
def test_exp_values(self): x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for ds in ['float32', 'float64']: log2_ = 0.69314718055994530943 xf = blaze.array(x, dshape=ds) yf = blaze.array(y, dshape=ds)*log2_ result = blaze.exp(yf) assert_almost_equal(result, xf)
def test_ragged(self): a = blaze.array([[1], [2, 3], [4, 5, 6]]) b = blaze.array([[1, 2, 3], [4, 5], [6]]) c = blaze.eval(a + b) self.assertEqual(dd_as_py(c._data), [[2, 3, 4], [6, 8], [10, 11, 12]]) c = blaze.eval(2 * a - b) self.assertEqual(dd_as_py(c._data), [[1, 0, -1], [0, 1], [2, 4, 6]])
def test_mixed(self): types1 = ['int8', 'int16', 'int32', 'int64'] types2 = ['int16', 'int32', 'float32', 'float64'] for ty1, ty2 in zip(types1, types2): a = blaze.array(range(1,6), dshape=ty1) b = blaze.array(range(5), dshape=ty2) c = (a+b)*(a-b) c = blaze.eval(c) result = [a*a - b*b for (a,b) in zip(range(1,6),range(5))] self.assertEqual(dd_as_py(c._data), result)
def test_create(self): a = blaze.array(date(2000, 1, 1)) self.assertEqual(a.dshape, dshape('date')) self.assertEqual(ddesc_as_py(a.ddesc), date(2000, 1, 1)) a = blaze.array([date(1490, 3, 12), date(2020, 7, 15)]) self.assertEqual(a.dshape, dshape('2 * date')) self.assertEqual(list(a), [date(1490, 3, 12), date(2020, 7, 15)]) a = blaze.array(['1490-03-12', '2020-07-15'], dshape='date') self.assertEqual(a.dshape, dshape('2 * date')) self.assertEqual(list(a), [date(1490, 3, 12), date(2020, 7, 15)])
def test_create(self): a = blaze.array(time(14, 30)) self.assertEqual(a.dshape, dshape('time')) self.assertEqual(ddesc_as_py(a.ddesc), time(14, 30)) a = blaze.array([time(14, 30), time(12, 25, 39, 123456)]) self.assertEqual(a.dshape, dshape('2 * time')) self.assertEqual(list(a), [time(14, 30), time(12, 25, 39, 123456)]) a = blaze.array(['2:30 pm', '12:25:39.123456'], dshape='time') self.assertEqual(a.dshape, dshape('2 * time')) self.assertEqual(list(a), [time(14, 30), time(12, 25, 39, 123456)])
def test_logaddexp2_range(self): x = [1000000, -1000000, 1000200, -1000200] y = [1000200, -1000200, 1000000, -1000000] z = [1000200, -1000000, 1000200, -1000000] for ds in ['float32', 'float64']: logxf = blaze.array(x, dshape=ds) logyf = blaze.array(y, dshape=ds) logzf = blaze.array(z, dshape=ds) result = blaze.logaddexp2(logxf, logyf) assert_almost_equal(result, logzf)
def test_logaddexp2_values(self): x = [1, 2, 3, 4, 5] y = [5, 4, 3, 2, 1] z = [6, 6, 6, 6, 6] for ds, dec in zip(['float32', 'float64'], [6, 15, 15]): xf = blaze.log2(blaze.array(x, dshape=ds)) yf = blaze.log2(blaze.array(y, dshape=ds)) zf = blaze.log2(blaze.array(z, dshape=ds)) result = blaze.logaddexp2(xf, yf) assert_almost_equal(result, zf, decimal=dec)
def test_create(self): ddesc = BLZ_DDesc(path=self.rootdir, mode='w') a = blaze.array([2], 'float64', ddesc=ddesc) self.assertTrue(isinstance(a, blaze.Array)) self.assertTrue(a.dshape.shape == (1, )) self.assertEqual(list(a), [2])
def test_create_record(self): ddesc = BLZ_DDesc(path=self.rootdir, mode='w') a = blaze.array([(1, 2)], '{x: int, y: real}', ddesc=ddesc) self.assertTrue(isinstance(a, blaze.Array)) self.assertTrue(a.dshape.shape == (1, )) self.assertEqual(list(a), [{'x': 1, 'y': 2.0}])