def test_sanitize_memory_layout(self):
# non distributed, 2D
a_torch = torch.arange(12, device=self.device.torch_device).reshape(4, 3)
a_heat_C = ht.array(a_torch)
a_heat_F = ht.array(a_torch, order="F")
self.assertTrue_memory_layout(a_heat_C, "C")
self.assertTrue_memory_layout(a_heat_F, "F")
# non distributed, 5D
a_torch_5d = torch.arange(4 * 3 * 5 * 2 * 1, device=self.device.torch_device).reshape(
4, 3, 1, 2, 5
)
a_heat_5d_C = ht.array(a_torch_5d)
a_heat_5d_F = ht.array(a_torch_5d, order="F")
self.assertTrue_memory_layout(a_heat_5d_C, "C")
self.assertTrue_memory_layout(a_heat_5d_F, "F")
a_heat_5d_F_sum = a_heat_5d_F.sum(-2)
a_torch_5d_sum = a_torch_5d.sum(-2)
self.assert_array_equal(a_heat_5d_F_sum, a_torch_5d_sum)
# distributed, split, 2D
size = ht.communication.MPI_WORLD.size
a_torch_2d = torch.arange(4 * size * 3 * size, device=self.device.torch_device).reshape(
4 * size, 3 * size
)
a_heat_2d_C_split = ht.array(a_torch_2d, split=0)
a_heat_2d_F_split = ht.array(a_torch_2d, split=1, order="F")
self.assertTrue_memory_layout(a_heat_2d_C_split, "C")
self.assertTrue_memory_layout(a_heat_2d_F_split, "F")
a_heat_2d_F_split_sum = a_heat_2d_F_split.sum(1)
a_torch_2d_sum = a_torch_2d.sum(1)
self.assert_array_equal(a_heat_2d_F_split_sum, a_torch_2d_sum)
# distributed, split, 5D
a_torch_5d = torch.arange(
4 * 3 * 5 * 2 * size * 7, device=self.device.torch_device
).reshape(4, 3, 7, 2 * size, 5)
a_heat_5d_C_split = ht.array(a_torch_5d, split=-2)
a_heat_5d_F_split = ht.array(a_torch_5d, split=-2, order="F")
self.assertTrue_memory_layout(a_heat_5d_C_split, "C")
self.assertTrue_memory_layout(a_heat_5d_F_split, "F")
a_heat_5d_F_split_sum = a_heat_5d_F_split.sum(-2)
a_torch_5d_sum = a_torch_5d.sum(-2)
self.assert_array_equal(a_heat_5d_F_split_sum, a_torch_5d_sum)
# distributed, is_split, 2D
a_heat_2d_C_issplit = ht.array(a_torch_2d, is_split=0)
a_heat_2d_F_issplit = ht.array(a_torch_2d, is_split=1, order="F")
self.assertTrue_memory_layout(a_heat_2d_C_issplit, "C")
self.assertTrue_memory_layout(a_heat_2d_F_issplit, "F")
a_heat_2d_F_issplit_sum = a_heat_2d_F_issplit.sum(1)
a_torch_2d_sum = a_torch_2d.sum(1) * size
self.assert_array_equal(a_heat_2d_F_issplit_sum, a_torch_2d_sum)
# distributed, is_split, 5D
a_heat_5d_C_issplit = ht.array(a_torch_5d, is_split=-2)
a_heat_5d_F_issplit = ht.array(a_torch_5d, is_split=-2, order="F")
self.assertTrue_memory_layout(a_heat_5d_C_issplit, "C")
self.assertTrue_memory_layout(a_heat_5d_F_issplit, "F")
a_heat_5d_F_issplit_sum = a_heat_5d_F_issplit.sum(-2)
a_torch_5d_sum = a_torch_5d.sum(-2) * size
self.assert_array_equal(a_heat_5d_F_issplit_sum, a_torch_5d_sum)
# test exceptions
with self.assertRaises(NotImplementedError):
ht.zeros_like(a_heat_5d_C_split, order="K")
def test_zeros_like(self):
# scalar
like_int = ht.zeros_like(3)
self.assertIsInstance(like_int, ht.tensor)
self.assertEqual(like_int.shape, (1, ))
self.assertEqual(like_int.lshape, (1, ))
self.assertEqual(like_int.split, None)
self.assertEqual(like_int.dtype, ht.int32)
self.assertEqual((like_int._tensor__array == 0).all().item(), 1)
# sequence
like_str = ht.zeros_like('abc')
self.assertIsInstance(like_str, ht.tensor)
self.assertEqual(like_str.shape, (3, ))
self.assertEqual(like_str.lshape, (3, ))
self.assertEqual(like_str.split, None)
self.assertEqual(like_str.dtype, ht.float32)
self.assertEqual((like_str._tensor__array == 0).all().item(), 1)
# elaborate tensor
ones = ht.ones((
2,
3,
), dtype=ht.uint8)
like_ones = ht.zeros_like(ones)
self.assertIsInstance(like_ones, ht.tensor)
self.assertEqual(like_ones.shape, (
2,
3,
))
self.assertEqual(like_ones.lshape, (
2,
3,
))
self.assertEqual(like_ones.split, None)
self.assertEqual(like_ones.dtype, ht.uint8)
self.assertEqual((like_ones._tensor__array == 0).all().item(), 1)
# elaborate tensor with split
ones_split = ht.ones((
2,
3,
), dtype=ht.uint8, split=0)
like_ones_split = ht.zeros_like(ones_split)
self.assertIsInstance(like_ones_split, ht.tensor)
self.assertEqual(like_ones_split.shape, (
2,
3,
))
self.assertLessEqual(like_ones_split.lshape[0], 2)
self.assertEqual(like_ones_split.lshape[1], 3)
self.assertEqual(like_ones_split.split, 0)
self.assertEqual(like_ones_split.dtype, ht.uint8)
self.assertEqual((like_ones_split._tensor__array == 0).all().item(), 1)
# exceptions
with self.assertRaises(TypeError):
ht.zeros_like(ones, dtype='abc')
with self.assertRaises(TypeError):
ht.zeros_like(ones, split='axis')
def test_modf(self):
size = ht.communication.MPI_WORLD.size
start, end = -5.0, 5.0
step = (end - start) / (2 * size)
npArray = np.arange(start, end, step, dtype=np.float32)
comparison = np.modf(npArray)
# exponential of float32
float32_tensor = ht.array(npArray, dtype=ht.float32)
float32_modf = float32_tensor.modf()
self.assertIsInstance(float32_modf[0], ht.DNDarray)
self.assertIsInstance(float32_modf[1], ht.DNDarray)
self.assertEqual(float32_modf[0].dtype, ht.float32)
self.assertEqual(float32_modf[1].dtype, ht.float32)
self.assert_array_equal(float32_modf[0], comparison[0])
self.assert_array_equal(float32_modf[1], comparison[1])
# exponential of float64
npArray = np.arange(start, end, step, np.float64)
comparison = np.modf(npArray)
float64_tensor = ht.array(npArray, dtype=ht.float64)
float64_modf = float64_tensor.modf()
self.assertIsInstance(float64_modf[0], ht.DNDarray)
self.assertIsInstance(float64_modf[1], ht.DNDarray)
self.assertEqual(float64_modf[0].dtype, ht.float64)
self.assertEqual(float64_modf[1].dtype, ht.float64)
self.assert_array_equal(float64_modf[0], comparison[0])
self.assert_array_equal(float64_modf[1], comparison[1])
# check exceptions
with self.assertRaises(TypeError):
ht.modf([0, 1, 2, 3])
with self.assertRaises(TypeError):
ht.modf(object())
with self.assertRaises(TypeError):
ht.modf(float32_tensor, 1)
with self.assertRaises(ValueError):
ht.modf(float32_tensor,
(float32_tensor, float32_tensor, float64_tensor))
with self.assertRaises(TypeError):
ht.modf(float32_tensor, (float32_tensor, 2))
# with split tensors
# exponential of float32
npArray = np.arange(start, end, step, dtype=np.float32)
comparison = np.modf(npArray)
float32_tensor_distrbd = ht.array(npArray, split=0)
float32_modf_distrbd = float32_tensor_distrbd.modf()
self.assertIsInstance(float32_modf_distrbd[0], ht.DNDarray)
self.assertIsInstance(float32_modf_distrbd[1], ht.DNDarray)
self.assertEqual(float32_modf_distrbd[0].dtype, ht.float32)
self.assertEqual(float32_modf_distrbd[1].dtype, ht.float32)
self.assert_array_equal(float32_modf_distrbd[0], comparison[0])
self.assert_array_equal(float32_modf_distrbd[1], comparison[1])
# exponential of float64
npArray = npArray = np.arange(start, end, step, np.float64)
comparison = np.modf(npArray)
float64_tensor_distrbd = ht.array(npArray, split=0)
float64_modf_distrbd = (
ht.zeros_like(float64_tensor_distrbd,
dtype=float64_tensor_distrbd.dtype),
ht.zeros_like(float64_tensor_distrbd,
dtype=float64_tensor_distrbd.dtype),
)
# float64_modf_distrbd = float64_tensor_distrbd.modf()
float64_tensor_distrbd.modf(out=float64_modf_distrbd)
self.assertIsInstance(float64_modf_distrbd[0], ht.DNDarray)
self.assertIsInstance(float64_modf_distrbd[1], ht.DNDarray)
self.assertEqual(float64_modf_distrbd[0].dtype, ht.float64)
self.assertEqual(float64_modf_distrbd[1].dtype, ht.float64)
self.assert_array_equal(float64_modf_distrbd[0], comparison[0])
self.assert_array_equal(float64_modf_distrbd[1], comparison[1])
