def test_ScaledBlockOperatorSingleScalar(self): ig = [ ImageGeometry(10,20,30) , \ ImageGeometry(10,20,30) , \ ImageGeometry(10,20,30) ] x = [g.allocate() for g in ig] ops = [IdentityOperator(g) for g in ig] val = 1 # test limit as non Scaled scalar = 1 k = BlockOperator(*ops) K = scalar * k X = BlockDataContainer(*x) + val Y = K.T.direct(X) self.assertTrue(Y.shape == (1, 1)) zero = numpy.zeros(X.get_item(0).shape) xx = numpy.asarray([val for _ in x]) numpy.testing.assert_array_equal( Y.get_item(0).as_array(), ((scalar * xx).sum() + zero)) scalar = 0.5 k = BlockOperator(*ops) K = scalar * k X = BlockDataContainer(*x) + 1 Y = K.T.direct(X) self.assertTrue(Y.shape == (1, 1)) zero = numpy.zeros(X.get_item(0).shape) numpy.testing.assert_array_equal( Y.get_item(0).as_array(), scalar * (len(x) + zero))
def test_ScaledBlockOperatorScalarList(self): ig = [ ImageGeometry(2,3) , \ #ImageGeometry(10,20,30) , \ ImageGeometry(2,3 ) ] x = [g.allocate() for g in ig] ops = [IdentityOperator(g) for g in ig] # test limit as non Scaled scalar = numpy.asarray([1 for _ in x]) k = BlockOperator(*ops) K = scalar * k val = 1 X = BlockDataContainer(*x) + val Y = K.T.direct(X) self.assertTrue(Y.shape == (1, 1)) zero = numpy.zeros(X.get_item(0).shape) xx = numpy.asarray([val for _ in x]) numpy.testing.assert_array_equal( Y.get_item(0).as_array(), (scalar * xx).sum() + zero) scalar = numpy.asarray([i + 1 for i, el in enumerate(x)]) #scalar = numpy.asarray([6,0]) k = BlockOperator(*ops) K = scalar * k X = BlockDataContainer(*x) + val Y = K.T.direct(X) self.assertTrue(Y.shape == (1, 1)) zero = numpy.zeros(X.get_item(0).shape) xx = numpy.asarray([val for _ in x]) numpy.testing.assert_array_equal( Y.get_item(0).as_array(), (scalar * xx).sum() + zero)
def test_axpby4(self): # test axpby with nested BlockDataContainer ig0 = ImageGeometry(2,3,4) ig1 = ImageGeometry(2,3,5) data0 = ig0.allocate(-1) data2 = ig0.allocate(1) # data1 = ig0.allocate(2) data3 = ig1.allocate(3) cp0 = BlockDataContainer(data0,data2) cp1 = BlockDataContainer(cp0 *0. + [2, -2], data3) print (cp1.get_item(0).get_item(0).as_array()) print (cp1.get_item(0).get_item(1).as_array()) print (cp1.get_item(1).as_array()) print ("###############################") out = cp1 * 0. cp2 = out + [1,3] print (cp2.get_item(0).get_item(0).as_array()) print (cp2.get_item(0).get_item(1).as_array()) print (cp2.get_item(1).as_array()) cp2.axpby(3,-2, cp1 ,out, num_threads=4) # output should be [ [ -1 , 7 ] , 3] res0 = ig0.allocate(-1) res2 = ig0.allocate(7) res3 = ig1.allocate(3) res = BlockDataContainer(BlockDataContainer(res0, res2), res3) # print ("res0", res0.as_array()) # print ("res2", res2.as_array()) print ("###############################") # print ("out_0", out.get_item(0).as_array()) # print ("out_1", out.get_item(1).as_array()) self.assertBlockDataContainerEqual(out, res)
def direct(self, x, out=None): '''Direct operation for the BlockOperator BlockOperator work on BlockDataContainer, but they will work on DataContainers and inherited classes by simple wrapping the input in a BlockDataContainer of shape (1,1) ''' if not isinstance(x, BlockDataContainer): x_b = BlockDataContainer(x) else: x_b = x shape = self.get_output_shape(x_b.shape) res = [] if out is None: for row in range(self.shape[0]): for col in range(self.shape[1]): if col == 0: prod = self.get_item(row, col).direct(x_b.get_item(col)) else: prod += self.get_item(row, col).direct(x_b.get_item(col)) res.append(prod) return BlockDataContainer(*res, shape=shape) else: tmp = self.range_geometry().allocate() for row in range(self.shape[0]): for col in range(self.shape[1]): if col == 0: self.get_item(row, col).direct(x_b.get_item(col), out=out.get_item(row)) else: a = out.get_item(row) self.get_item(row, col).direct(x_b.get_item(col), out=tmp.get_item(row)) a += tmp.get_item(row)
def adjoint(self, x, out=None): '''Adjoint operation for the BlockOperator BlockOperator may contain both LinearOperator and Operator This method exists in BlockOperator as it is not known what type of Operator it will contain. BlockOperator work on BlockDataContainer, but they will work on DataContainers and inherited classes by simple wrapping the input in a BlockDataContainer of shape (1,1) Raises: ValueError if the contained Operators are not linear ''' if not self.is_linear(): raise ValueError('Not all operators in Block are linear.') if not isinstance(x, BlockDataContainer): x_b = BlockDataContainer(x) else: x_b = x shape = self.get_output_shape(x_b.shape, adjoint=True) if out is None: res = [] for col in range(self.shape[1]): for row in range(self.shape[0]): if row == 0: prod = self.get_item(row, col).adjoint(x_b.get_item(row)) else: prod += self.get_item(row, col).adjoint(x_b.get_item(row)) res.append(prod) if self.shape[1] == 1: # the output is a single DataContainer, so we can take it out return res[0] else: return BlockDataContainer(*res, shape=shape) else: for col in range(self.shape[1]): for row in range(self.shape[0]): if row == 0: if issubclass(out.__class__, DataContainer) or \ ( has_sirf and issubclass(out.__class__, SIRFDataContainer) ): self.get_item(row, col).adjoint(x_b.get_item(row), out=out) else: op = self.get_item(row, col) self.get_item(row, col).adjoint(x_b.get_item(row), out=out.get_item(col)) else: if issubclass(out.__class__, DataContainer) or \ ( has_sirf and issubclass(out.__class__, SIRFDataContainer) ): out += self.get_item(row, col).adjoint( x_b.get_item(row)) else: a = out.get_item(col) a += self.get_item(row, col).adjoint( x_b.get_item(row), )
def test_BlockOperator(self): print("test_BlockOperator") ig = [ ImageGeometry(10,20,30) , \ ImageGeometry(10,20,30) , \ ImageGeometry(10,20,30) ] x = [g.allocate() for g in ig] ops = [IdentityOperator(g) for g in ig] K = BlockOperator(*ops) X = BlockDataContainer(x[0]) Y = K.direct(X) self.assertTrue(Y.shape == K.shape) numpy.testing.assert_array_equal( Y.get_item(0).as_array(), X.get_item(0).as_array()) numpy.testing.assert_array_equal( Y.get_item(1).as_array(), X.get_item(0).as_array()) #numpy.testing.assert_array_equal(Y.get_item(2).as_array(),X.get_item(2).as_array()) X = BlockDataContainer(*x) + 1 Y = K.T.direct(X) # K.T (1,3) X (3,1) => output shape (1,1) self.assertTrue(Y.shape == (1, 1)) zero = numpy.zeros(X.get_item(0).shape) numpy.testing.assert_array_equal( Y.get_item(0).as_array(), len(x) + zero) K2 = BlockOperator(*(ops + ops), shape=(3, 2)) Y = K2.T.direct(X) # K.T (2,3) X (3,1) => output shape (2,1) self.assertTrue(Y.shape == (2, 1)) try: # this should fail as the domain is not compatible ig = [ ImageGeometry(10,20,31) , \ ImageGeometry(10,20,30) , \ ImageGeometry(10,20,30) ] x = [g.allocate() for g in ig] ops = [IdentityOperator(g) for g in ig] K = BlockOperator(*ops) self.assertFalse(K.column_wise_compatible()) except ValueError as ve: print(ve) self.assertTrue(True) try: # this should fail as the range is not compatible ig = [ ImageGeometry(10,20,30) , \ ImageGeometry(10,20,30) , \ ImageGeometry(10,20,30) ] rg0 = [ ImageGeometry(10,20,31) , \ ImageGeometry(10,20,31) , \ ImageGeometry(10,20,31) ] rg1 = [ ImageGeometry(10,22,31) , \ ImageGeometry(10,22,31) , \ ImageGeometry(10,20,31) ] x = [g.allocate() for g in ig] ops = [ IdentityOperator(g, range_geometry=r) for g, r in zip(ig, rg0) ] ops += [ IdentityOperator(g, range_geometry=r) for g, r in zip(ig, rg1) ] K = BlockOperator(*ops, shape=(2, 3)) print("K col comp? ", K.column_wise_compatible()) print("K row comp? ", K.row_wise_compatible()) for op in ops: print("range", op.range_geometry().shape) for op in ops: print("domain", op.domain_geometry().shape) self.assertFalse(K.row_wise_compatible()) except ValueError as ve: print(ve) self.assertTrue(True)
def test_Nested_BlockDataContainer(self): ig0 = ImageGeometry(2, 3, 4) ig1 = ImageGeometry(2, 3, 4) # data0 = ImageData(geometry=ig0) # data1 = ImageData(geometry=ig1) + 1 # data2 = ImageData(geometry=ig0) + 2 # data3 = ImageData(geometry=ig1) + 3 data0 = ig0.allocate(0.) data1 = ig1.allocate(1.) data2 = ig0.allocate(2.) data3 = ig1.allocate(3.) cp0 = BlockDataContainer(data0, data1) cp1 = BlockDataContainer(data2, data3) nbdc = BlockDataContainer(cp0, cp1) nbdc2 = nbdc + 2 numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(0).as_array()[0][0][0], 2., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(1).as_array()[0][0][0], 3., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(0).as_array()[0][0][0], 4., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(1).as_array()[0][0][0], 5., decimal=5) nbdc2 = 2 + nbdc numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(0).as_array()[0][0][0], 2., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(1).as_array()[0][0][0], 3., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(0).as_array()[0][0][0], 4., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(1).as_array()[0][0][0], 5., decimal=5) nbdc2 = nbdc * 2 numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(1).as_array()[0][0][0], 2., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(0).as_array()[0][0][0], 4., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(1).as_array()[0][0][0], 6., decimal=5) nbdc2 = 2 * nbdc numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(1).as_array()[0][0][0], 2., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(0).as_array()[0][0][0], 4., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(1).as_array()[0][0][0], 6., decimal=5) nbdc2 = nbdc / 2 numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(0).get_item(1).as_array()[0][0][0], .5, decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(0).as_array()[0][0][0], 1., decimal=5) numpy.testing.assert_almost_equal( nbdc2.get_item(1).get_item(1).as_array()[0][0][0], 3. / 2, decimal=5) c5 = nbdc.get_item(0).power(2).sum() c5a = nbdc.power(2).sum() cp0 = BlockDataContainer(data0, data2) a = cp0 * data2 b = data2 * cp0 self.assertBlockDataContainerEqual(a, b)
def test_BlockDataContainer(self): ig0 = ImageGeometry(2, 3, 4) ig1 = ImageGeometry(2, 3, 5) # data0 = ImageData(geometry=ig0) # data1 = ImageData(geometry=ig1) + 1 data0 = ig0.allocate(0.) data1 = ig1.allocate(1.) # data2 = ImageData(geometry=ig0) + 2 # data3 = ImageData(geometry=ig1) + 3 data2 = ig0.allocate(2.) data3 = ig1.allocate(3.) cp0 = BlockDataContainer(data0, data1) cp1 = BlockDataContainer(data2, data3) cp2 = BlockDataContainer(data0 + 1, data2 + 1) d = cp2 + data0 self.assertEqual(d.get_item(0).as_array()[0][0][0], 1) try: d = cp2 + data1 self.assertTrue(False) except ValueError as ve: self.assertTrue(True) d = cp2 - data0 self.assertEqual(d.get_item(0).as_array()[0][0][0], 1) try: d = cp2 - data1 self.assertTrue(False) except ValueError as ve: self.assertTrue(True) d = cp2 * data2 self.assertEqual(d.get_item(0).as_array()[0][0][0], 2) try: d = cp2 * data1 self.assertTrue(False) except ValueError as ve: self.assertTrue(True) a = [(el, ot) for el, ot in zip(cp0.containers, cp1.containers)] #cp2 = BlockDataContainer(*a) cp2 = cp0.add(cp1) self.assertEqual(cp2.get_item(0).as_array()[0][0][0], 2.) self.assertEqual(cp2.get_item(1).as_array()[0][0][0], 4.) cp2 = cp0 + cp1 self.assertTrue(cp2.get_item(0).as_array()[0][0][0] == 2.) self.assertTrue(cp2.get_item(1).as_array()[0][0][0] == 4.) cp2 = cp0 + 1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 1., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 2., decimal=5) cp2 = cp0 + [1, 2] numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 1., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 3., decimal=5) cp2 += cp1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], +3., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], +6., decimal=5) cp2 += 1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], +4., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], +7., decimal=5) cp2 += [-2, -1] numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 2., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 6., decimal=5) cp2 = cp0.subtract(cp1) assert (cp2.get_item(0).as_array()[0][0][0] == -2.) assert (cp2.get_item(1).as_array()[0][0][0] == -2.) cp2 = cp0 - cp1 assert (cp2.get_item(0).as_array()[0][0][0] == -2.) assert (cp2.get_item(1).as_array()[0][0][0] == -2.) cp2 = cp0 - 1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], -1., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 0, decimal=5) cp2 = cp0 - [1, 2] numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], -1., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], -1., decimal=5) cp2 -= cp1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], -3., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], -4., decimal=5) cp2 -= 1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], -4., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], -5., decimal=5) cp2 -= [-2, -1] numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], -2., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], -4., decimal=5) cp2 = cp0.multiply(cp1) assert (cp2.get_item(0).as_array()[0][0][0] == 0.) assert (cp2.get_item(1).as_array()[0][0][0] == 3.) cp2 = cp0 * cp1 assert (cp2.get_item(0).as_array()[0][0][0] == 0.) assert (cp2.get_item(1).as_array()[0][0][0] == 3.) cp2 = cp0 * 2 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 2, decimal=5) cp2 = 2 * cp0 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 2, decimal=5) cp2 = cp0 * [3, 2] numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 2., decimal=5) cp2 = cp0 * numpy.asarray([3, 2]) numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 2., decimal=5) cp2 = [3, 2] * cp0 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 2., decimal=5) cp2 = numpy.asarray([3, 2]) * cp0 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 2., decimal=5) try: cp2 = [3, 2, 3] * cp0 #numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0] , 0. , decimal=5) #numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0] , 2., decimal = 5) self.assertTrue(False) except ValueError as ve: self.assertTrue(True) cp2 *= cp1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0, decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], +6., decimal=5) cp2 *= 1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], +6., decimal=5) cp2 *= [-2, -1] numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], -6., decimal=5) try: cp2 *= [2, 3, 5] self.assertTrue(False) except ValueError as ve: self.assertTrue(True) cp2 = cp0.divide(cp1) assert (cp2.get_item(0).as_array()[0][0][0] == 0.) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 1. / 3., decimal=4) cp2 = cp0 / cp1 assert (cp2.get_item(0).as_array()[0][0][0] == 0.) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 1. / 3., decimal=4) cp2 = cp0 / 2 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 0.5, decimal=5) cp2 = cp0 / [3, 2] numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 0.5, decimal=5) cp2 = cp0 / numpy.asarray([3, 2]) numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 0.5, decimal=5) cp3 = numpy.asarray([3, 2]) / (cp0 + 1) numpy.testing.assert_almost_equal(cp3.get_item(0).as_array()[0][0][0], 3., decimal=5) numpy.testing.assert_almost_equal(cp3.get_item(1).as_array()[0][0][0], 1, decimal=5) cp2 += 1 cp2 /= cp1 # TODO fix inplace division numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 1. / 2, decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 1.5 / 3., decimal=5) cp2 /= 1 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0.5, decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 0.5, decimal=5) cp2 /= [-2, -1] numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], -0.5 / 2., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], -0.5, decimal=5) #### cp2 = cp0.power(cp1) assert (cp2.get_item(0).as_array()[0][0][0] == 0.) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 1., decimal=4) cp2 = cp0**cp1 assert (cp2.get_item(0).as_array()[0][0][0] == 0.) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 1., decimal=4) cp2 = cp0**2 numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=5) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 1., decimal=5) cp2 = cp0.maximum(cp1) assert (cp2.get_item(0).as_array()[0][0][0] == cp1.get_item( 0).as_array()[0][0][0]) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], cp2.get_item(1).as_array()[0][0][0], decimal=4) cp2 = cp0.abs() numpy.testing.assert_almost_equal(cp2.get_item(0).as_array()[0][0][0], 0., decimal=4) numpy.testing.assert_almost_equal(cp2.get_item(1).as_array()[0][0][0], 1., decimal=4) cp2 = cp0.subtract(cp1) s = cp2.sign() numpy.testing.assert_almost_equal(s.get_item(0).as_array()[0][0][0], -1., decimal=4) numpy.testing.assert_almost_equal(s.get_item(1).as_array()[0][0][0], -1., decimal=4) cp2 = cp0.add(cp1) s = cp2.sqrt() numpy.testing.assert_almost_equal(s.get_item(0).as_array()[0][0][0], numpy.sqrt(2), decimal=4) numpy.testing.assert_almost_equal(s.get_item(1).as_array()[0][0][0], numpy.sqrt(4), decimal=4) s = cp0.sum() size = functools.reduce(lambda x, y: x * y, data1.shape, 1) numpy.testing.assert_almost_equal(s, 0 + size, decimal=4) s0 = 1 s1 = 1 for i in cp0.get_item(0).shape: s0 *= i for i in cp0.get_item(1).shape: s1 *= i