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