Example #1
0
    def test_block_memory_order(self, block):
        # 3D
        arr_c = np.zeros((3,)*3, order='C')
        arr_f = np.zeros((3,)*3, order='F')

        b_c = [[[arr_c, arr_c],
                [arr_c, arr_c]],
               [[arr_c, arr_c],
                [arr_c, arr_c]]]

        b_f = [[[arr_f, arr_f],
                [arr_f, arr_f]],
               [[arr_f, arr_f],
                [arr_f, arr_f]]]

        assert block(b_c).flags['C_CONTIGUOUS']
        assert block(b_f).flags['F_CONTIGUOUS']

        arr_c = np.zeros((3, 3), order='C')
        arr_f = np.zeros((3, 3), order='F')
        # 2D
        b_c = [[arr_c, arr_c],
               [arr_c, arr_c]]

        b_f = [[arr_f, arr_f],
               [arr_f, arr_f]]

        assert block(b_c).flags['C_CONTIGUOUS']
        assert block(b_f).flags['F_CONTIGUOUS']
Example #2
0
    def test_block_memory_order(self, block):
        # 3D
        arr_c = np.zeros((3,)*3, order='C')
        arr_f = np.zeros((3,)*3, order='F')

        b_c = [[[arr_c, arr_c],
                [arr_c, arr_c]],
               [[arr_c, arr_c],
                [arr_c, arr_c]]]

        b_f = [[[arr_f, arr_f],
                [arr_f, arr_f]],
               [[arr_f, arr_f],
                [arr_f, arr_f]]]

        assert block(b_c).flags['C_CONTIGUOUS']
        assert block(b_f).flags['F_CONTIGUOUS']

        arr_c = np.zeros((3, 3), order='C')
        arr_f = np.zeros((3, 3), order='F')
        # 2D
        b_c = [[arr_c, arr_c],
               [arr_c, arr_c]]

        b_f = [[arr_f, arr_f],
               [arr_f, arr_f]]

        assert block(b_c).flags['C_CONTIGUOUS']
        assert block(b_f).flags['F_CONTIGUOUS']
Example #3
0
    def test_nested(self, block):
        one = np.array([1, 1, 1])
        two = np.array([[2, 2, 2], [2, 2, 2], [2, 2, 2]])
        three = np.array([3, 3, 3])
        four = np.array([4, 4, 4])
        five = np.array(5)
        six = np.array([6, 6, 6, 6, 6])
        zero = np.zeros((2, 6))

        result = block([
            [
                block([
                   [one],
                   [three],
                   [four]
                ]),
                two
            ],
            [five, six],
            [zero]
        ])
        expected = np.array([[1, 1, 1, 2, 2, 2],
                             [3, 3, 3, 2, 2, 2],
                             [4, 4, 4, 2, 2, 2],
                             [5, 6, 6, 6, 6, 6],
                             [0, 0, 0, 0, 0, 0],
                             [0, 0, 0, 0, 0, 0]])

        assert_equal(result, expected)
Example #4
0
    def test_nested(self, block):
        one = np.array([1, 1, 1])
        two = np.array([[2, 2, 2], [2, 2, 2], [2, 2, 2]])
        three = np.array([3, 3, 3])
        four = np.array([4, 4, 4])
        five = np.array(5)
        six = np.array([6, 6, 6, 6, 6])
        zero = np.zeros((2, 6))

        result = block([
            [
                block([
                   [one],
                   [three],
                   [four]
                ]),
                two
            ],
            [five, six],
            [zero]
        ])
        expected = np.array([[1, 1, 1, 2, 2, 2],
                             [3, 3, 3, 2, 2, 2],
                             [4, 4, 4, 2, 2, 2],
                             [5, 6, 6, 6, 6, 6],
                             [0, 0, 0, 0, 0, 0],
                             [0, 0, 0, 0, 0, 0]])

        assert_equal(result, expected)
Example #5
0
 def test_block_with_1d_arrays_multiple_rows(self, block):
     a = np.array([1, 2, 3])
     b = np.array([2, 3, 4])
     expected = np.array([[1, 2, 3, 2, 3, 4],
                          [1, 2, 3, 2, 3, 4]])
     result = block([[a, b], [a, b]])
     assert_equal(expected, result)
Example #6
0
 def test_block_with_1d_arrays_row_wise(self, block):
     # # # 1-D vectors are treated as row arrays
     a = np.array([1, 2, 3])
     b = np.array([2, 3, 4])
     expected = np.array([1, 2, 3, 2, 3, 4])
     result = block([a, b])
     assert_equal(expected, result)
Example #7
0
 def test_block_simple_row_wise(self, block):
     a_2d = np.ones((2, 2))
     b_2d = 2 * a_2d
     desired = np.array([[1, 1, 2, 2],
                         [1, 1, 2, 2]])
     result = block([a_2d, b_2d])
     assert_equal(desired, result)
Example #8
0
 def test_block_with_1d_arrays_column_wise(self):
     # # # 1-D vectors are treated as row arrays
     a_1d = np.array([1, 2, 3])
     b_1d = np.array([2, 3, 4])
     expected = np.array([[1, 2, 3], [2, 3, 4]])
     result = block([[a_1d], [b_1d]])
     assert_equal(expected, result)
Example #9
0
 def test_block_simple_row_wise(self):
     a_2d = np.ones((2, 2))
     b_2d = 2 * a_2d
     desired = np.array([[1, 1, 2, 2],
                         [1, 1, 2, 2]])
     result = block([a_2d, b_2d])
     assert_equal(desired, result)
Example #10
0
 def test_block_with_1d_arrays_row_wise(self):
     # # # 1-D vectors are treated as row arrays
     a = np.array([1, 2, 3])
     b = np.array([2, 3, 4])
     expected = np.array([1, 2, 3, 2, 3, 4])
     result = block([a, b])
     assert_equal(expected, result)
Example #11
0
 def test_block_with_1d_arrays_multiple_rows(self):
     a = np.array([1, 2, 3])
     b = np.array([2, 3, 4])
     expected = np.array([[1, 2, 3, 2, 3, 4],
                          [1, 2, 3, 2, 3, 4]])
     result = block([[a, b], [a, b]])
     assert_equal(expected, result)
Example #12
0
    def test_3d(self, block):
        a000 = np.ones((2, 2, 2), int) * 1

        a100 = np.ones((3, 2, 2), int) * 2
        a010 = np.ones((2, 3, 2), int) * 3
        a001 = np.ones((2, 2, 3), int) * 4

        a011 = np.ones((2, 3, 3), int) * 5
        a101 = np.ones((3, 2, 3), int) * 6
        a110 = np.ones((3, 3, 2), int) * 7

        a111 = np.ones((3, 3, 3), int) * 8

        result = block([[
            [a000, a001],
            [a010, a011],
        ], [
            [a100, a101],
            [a110, a111],
        ]])
        expected = array([[[1, 1, 4, 4, 4], [1, 1, 4, 4, 4], [3, 3, 5, 5, 5],
                           [3, 3, 5, 5, 5], [3, 3, 5, 5, 5]],
                          [[1, 1, 4, 4, 4], [1, 1, 4, 4, 4], [3, 3, 5, 5, 5],
                           [3, 3, 5, 5, 5], [3, 3, 5, 5, 5]],
                          [[2, 2, 6, 6, 6], [2, 2, 6, 6, 6], [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8], [7, 7, 8, 8, 8]],
                          [[2, 2, 6, 6, 6], [2, 2, 6, 6, 6], [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8], [7, 7, 8, 8, 8]],
                          [[2, 2, 6, 6, 6], [2, 2, 6, 6, 6], [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8], [7, 7, 8, 8, 8]]])

        assert_array_equal(result, expected)
Example #13
0
 def test_block_with_1d_arrays_column_wise(self, block):
     # # # 1-D vectors are treated as row arrays
     a_1d = np.array([1, 2, 3])
     b_1d = np.array([2, 3, 4])
     expected = np.array([[1, 2, 3],
                          [2, 3, 4]])
     result = block([[a_1d], [b_1d]])
     assert_equal(expected, result)
Example #14
0
 def test_block_mixed_1d_and_2d(self):
     a_2d = np.ones((2, 2))
     b_1d = np.array([2, 2])
     result = block([[a_2d], [b_1d]])
     expected = np.array([[1, 1],
                          [1, 1],
                          [2, 2]])
     assert_equal(expected, result)
Example #15
0
 def test_block_mixed_1d_and_2d(self, block):
     a_2d = np.ones((2, 2))
     b_1d = np.array([2, 2])
     result = block([[a_2d], [b_1d]])
     expected = np.array([[1, 1],
                          [1, 1],
                          [2, 2]])
     assert_equal(expected, result)
Example #16
0
 def test_block_simple_column_wise(self, block):
     a_2d = np.ones((2, 2))
     b_2d = 2 * a_2d
     expected = np.array([[1, 1],
                          [1, 1],
                          [2, 2],
                          [2, 2]])
     result = block([[a_2d], [b_2d]])
     assert_equal(expected, result)
Example #17
0
    def test_different_ndims(self, block):
        a = 1.
        b = 2 * np.ones((1, 2))
        c = 3 * np.ones((1, 1, 3))

        result = block([a, b, c])
        expected = np.array([[[1., 2., 2., 3., 3., 3.]]])

        assert_equal(result, expected)
Example #18
0
 def test_block_simple_column_wise(self):
     a_2d = np.ones((2, 2))
     b_2d = 2 * a_2d
     expected = np.array([[1, 1],
                          [1, 1],
                          [2, 2],
                          [2, 2]])
     result = block([[a_2d], [b_2d]])
     assert_equal(expected, result)
Example #19
0
    def test_different_ndims_depths(self, block):
        a = 1.
        b = 2 * np.ones((1, 2))
        c = 3 * np.ones((1, 2, 3))

        result = block([[a, b], [c]])
        expected = np.array([[[1., 2., 2.], [3., 3., 3.], [3., 3., 3.]]])

        assert_equal(result, expected)
Example #20
0
    def test_different_ndims(self, block):
        a = 1.0
        b = 2 * np.ones((1, 2))
        c = 3 * np.ones((1, 1, 3))

        result = block([a, b, c])
        expected = np.array([[[1.0, 2.0, 2.0, 3.0, 3.0, 3.0]]])

        assert_equal(result, expected)
Example #21
0
    def test_3d(self, block):
        a000 = np.ones((2, 2, 2), int) * 1

        a100 = np.ones((3, 2, 2), int) * 2
        a010 = np.ones((2, 3, 2), int) * 3
        a001 = np.ones((2, 2, 3), int) * 4

        a011 = np.ones((2, 3, 3), int) * 5
        a101 = np.ones((3, 2, 3), int) * 6
        a110 = np.ones((3, 3, 2), int) * 7

        a111 = np.ones((3, 3, 3), int) * 8

        result = block([
            [
                [a000, a001],
                [a010, a011],
            ],
            [
                [a100, a101],
                [a110, a111],
            ]
        ])
        expected = array([[[1, 1, 4, 4, 4],
                           [1, 1, 4, 4, 4],
                           [3, 3, 5, 5, 5],
                           [3, 3, 5, 5, 5],
                           [3, 3, 5, 5, 5]],

                          [[1, 1, 4, 4, 4],
                           [1, 1, 4, 4, 4],
                           [3, 3, 5, 5, 5],
                           [3, 3, 5, 5, 5],
                           [3, 3, 5, 5, 5]],

                          [[2, 2, 6, 6, 6],
                           [2, 2, 6, 6, 6],
                           [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8]],

                          [[2, 2, 6, 6, 6],
                           [2, 2, 6, 6, 6],
                           [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8]],

                          [[2, 2, 6, 6, 6],
                           [2, 2, 6, 6, 6],
                           [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8],
                           [7, 7, 8, 8, 8]]])

        assert_array_equal(result, expected)
Example #22
0
    def test_block_memory_order(self, block):
        # 3D
        arr_c = np.zeros((3, ) * 3, order="C")
        arr_f = np.zeros((3, ) * 3, order="F")

        b_c = [[[arr_c, arr_c], [arr_c, arr_c]],
               [[arr_c, arr_c], [arr_c, arr_c]]]

        b_f = [[[arr_f, arr_f], [arr_f, arr_f]],
               [[arr_f, arr_f], [arr_f, arr_f]]]

        assert block(b_c).flags["C_CONTIGUOUS"]
        assert block(b_f).flags["F_CONTIGUOUS"]

        arr_c = np.zeros((3, 3), order="C")
        arr_f = np.zeros((3, 3), order="F")
        # 2D
        b_c = [[arr_c, arr_c], [arr_c, arr_c]]

        b_f = [[arr_f, arr_f], [arr_f, arr_f]]

        assert block(b_c).flags["C_CONTIGUOUS"]
        assert block(b_f).flags["F_CONTIGUOUS"]
Example #23
0
    def test_block_complicated(self):
        # a bit more complicated
        one_2d = np.array([[1, 1, 1]])
        two_2d = np.array([[2, 2, 2]])
        three_2d = np.array([[3, 3, 3, 3, 3, 3]])
        four_1d = np.array([4, 4, 4, 4, 4, 4])
        five_0d = np.array(5)
        six_1d = np.array([6, 6, 6, 6, 6])
        zero_2d = np.zeros((2, 6))

        expected = np.array([[1, 1, 1, 2, 2, 2], [3, 3, 3, 3, 3, 3],
                             [4, 4, 4, 4, 4, 4], [5, 6, 6, 6, 6, 6],
                             [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]])

        result = block([[one_2d, two_2d], [three_2d], [four_1d],
                        [five_0d, six_1d], [zero_2d]])
        assert_equal(result, expected)
Example #24
0
    def test_block_complicated(self, block):
        # a bit more complicated
        one_2d = np.array([[1, 1, 1]])
        two_2d = np.array([[2, 2, 2]])
        three_2d = np.array([[3, 3, 3, 3, 3, 3]])
        four_1d = np.array([4, 4, 4, 4, 4, 4])
        five_0d = np.array(5)
        six_1d = np.array([6, 6, 6, 6, 6])
        zero_2d = np.zeros((2, 6))

        expected = np.array([[1, 1, 1, 2, 2, 2],
                             [3, 3, 3, 3, 3, 3],
                             [4, 4, 4, 4, 4, 4],
                             [5, 6, 6, 6, 6, 6],
                             [0, 0, 0, 0, 0, 0],
                             [0, 0, 0, 0, 0, 0]])

        result = block([[one_2d, two_2d],
                        [three_2d],
                        [four_1d],
                        [five_0d, six_1d],
                        [zero_2d]])
        assert_equal(result, expected)
Example #25
0
 def test_no_lists(self, block):
     assert_equal(block(1),         np.array(1))
     assert_equal(block(np.eye(3)), np.eye(3))
Example #26
0
 def test_returns_copy(self, block):
     a = np.eye(3)
     b = block(a)
     b[0, 0] = 2
     assert b[0, 0] != a[0, 0]
Example #27
0
 def test_returns_copy(self, block):
     a = np.eye(3)
     b = block(a)
     b[0, 0] = 2
     assert b[0, 0] != a[0, 0]
Example #28
0
 def test_no_lists(self, block):
     assert_equal(block(1), np.array(1))
     assert_equal(block(np.eye(3)), np.eye(3))