def test_evaluate(self):
a = np.arange(25).reshape(5, 5)
t = pt.tensor([5, 5], pt.csr)
for i in range(5):
t.insert([i, i], a[i, i])
c = pt.evaluate("T(j) = A(i, j)", a)
self.assertTrue(np.array_equal(c.to_array(), a.sum(axis=0)))
result = pt.tensor([5], pt.dense)
v = pt.evaluate("T(j) = A(i, j)", result, t)
self.assertEqual(v, result)
def test_reduce(self):
arr = np.arange(1, 5).reshape([2, 2])
t = pt.from_array(arr)
res = pt.tensor()
i, j = pt.get_index_vars(2)
res[None] = pt.sum(j, pt.sum(i, t[i, j]))
self.assertEqual(res[0], np.sum(arr))
def test_mod(self):
arr = np.arange(1, 5).reshape([2, 2])
t = pt.from_array(arr)
t1 = pt.tensor([2, 2], pt.dense)
i, j = pt.get_index_vars(2)
t1[i, j] = pt.remainder(t[i, j], 2)
self.assertEqual(t1, arr % 2)
def test_iterator(self):
in_components = [([0, 1], 1.0), ([2, 2], 2.0), ([2, 3], 3.0), ([4, 0], 4.0)]
A = pt.tensor([5, 5], pt.csr)
for coords, val in in_components:
A.insert(coords, val)
A.insert([3, 3], 0.0)
out_components = [components for components in A]
self.assertTrue(in_components == out_components)
def setUp(self):
self.dir_name = tempfile.mkdtemp()
self.names = [os.path.join(self.dir_name, dtype.__repr__() + "{}".format(i)) for i, dtype in enumerate(types)]
tensors = [np.ones([3, 3]).astype(pt.as_np_dtype(dt)) for dt in types]
self.tensors = [pt.from_array(t, copy=True) for t in tensors]
self.comp_tensors = [pt.tensor([3, 3], pt.csc, dt) for dt in types]
self.coord = [2, 2]
self.val = 10
for t2 in self.comp_tensors:
t2.insert(self.coord, self.val) # force .tns to infer 3x3 shape
def random(shape, format='dense', density=1.):
if format == "dense":
return pt.from_array(np.random.random(shape))
elif format == "coo":
sp_tensor = sparse.random(shape, density=density, format='coo')
pt_tensor = pt.tensor(shape, pt.compressed)
for i in range(len(sp_tensor.data)):
pt_tensor.insert(sp_tensor.coords[:, i], sp_tensor.data[i])
return pt_tensor
else:
raise NotImplementedError
def tensor(data, dtype=None, format="dense"):
"""
Parameters
----------
data: the input multidimentional array.
dtype: datatype
format: a string denoting the tensor datatype.
if "dense", then return a dense tensor.
if "coo", then return a sparse tensor in the COO format.
"""
if format == "dense":
return pt.from_array(np.array(data))
elif format == "coo":
sp_tensor = sparse.COO.from_numpy(np.array(data, dtype=dtype))
pt_tensor = pt.tensor(sp_tensor.shape, pt.compressed)
for i in range(len(sp_tensor.data)):
pt_tensor.insert(sp_tensor.coords[:, i], sp_tensor.data[i])
return pt_tensor
else:
raise NotImplementedError
def setUp(self):
self.shape2 = [10, 10]
self.shape5 = [4, 4, 4, 4, 4]
self.format2 = pt.csr
self.format5 = pt.format([pt.compressed]*5)
self.implicit_scalar = pt.tensor([])
self.false_bool_tensor = pt.tensor(False)
self.scalars = [pt.tensor(dtype=dt) for dt in types]
self.order2 = [pt.tensor(self.shape2, self.format2, dtype=dt) for dt in types]
self.order5 = [pt.tensor(self.shape5, pt.compressed, dt) for dt in types]
self.setScalar = [pt.tensor(i, dtype=dt) for i, dt in enumerate(types)]
self.c_array = np.array(np.arange(100).reshape([10, 10]), order='C')
self.f_array = np.array(np.arange(100).reshape([10, 10]), order='F')
