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}])
