Esempio n. 1
0
    def test_unary_sqrt2(self):
        # test axpby with nested BlockDataContainer
        data0 = self.ig0.allocate(4)
        data2 = self.ig1.allocate(8)

        # data1 = ig0.allocate(2)
        # data3 = ig1.allocate(3)
        
        cp0 = BlockDataContainer(data0,data2)
        cp0.sqrt(out=cp0)
        res = BlockDataContainer(self.ig0.allocate(numpy.sqrt(4)), self.ig1.allocate(numpy.sqrt(8)))
        self.assertBlockDataContainerAlmostEqual(res, cp0)
Esempio n. 2
0
    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