T_linear_values

wield.control.linear_values.test.T_linear_values

This is a pytest module needing documentation

pytest-html report

Functions

T_linear_values()

This is a pytest needing documentation

Details

T_linear_values()[source][github]

This is a pytest needing documentation

code
  1def T_linear_values():
  2    ZERO = lv.scalar(0)
  3    IDENT = lv.scalar(1)
  4    SCALAR = lv.scalar(2)
  5    SCALARa = lv.scalar(np.arange(2))
  6
  7    DIAG = lv.diagonal([2, 4])
  8    DIAGa = lv.diagonal([2, 4 + np.arange(2)])
  9
 10    MAT = lv.matrix(
 11        [[0, 1],
 12        [-1, 0]]
 13    )
 14
 15    MATa = lv.matrix(
 16        [[0, 1],
 17        [-1, np.arange(2)]]
 18    )
 19    print("TEST", MATa.value)
 20
 21    print(MAT @ MAT)
 22    assert(np.all(MAT @ MAT == lv.matrix(
 23        [[-1, 0],
 24         [0, -1]])
 25    ))
 26    print(DIAG @ MAT)
 27    assert(np.all(DIAG @ MAT == lv.matrix(
 28        [[0, 2],
 29         [-4, 0]])
 30    ))
 31    print(MAT @ DIAG)
 32    assert(np.all(MAT @ DIAG == lv.matrix(
 33        [[0, 4],
 34         [-2, 0]])
 35    ))
 36    print(DIAG @ DIAG)
 37    assert(np.all(DIAG @ DIAG == lv.diagonal(
 38        [4, 16]
 39    )))
 40
 41    print(DIAG @ SCALAR)
 42    print(SCALAR @ DIAG)
 43    assert(np.all(DIAG @ SCALAR == lv.diagonal(
 44        [4, 8]
 45    )))
 46
 47    print(MAT @ SCALAR)
 48    print(SCALAR @ MAT)
 49    assert(np.all(MAT @ SCALAR == lv.matrix(
 50        [[0, 2],
 51         [-2, 0]])
 52    ))
 53
 54    print('--------------')
 55    # now the array style
 56    print("A", MATa @ MAT)
 57    print("B", MAT @ MATa)
 58    print("C", MATa @ MATa)
 59    assert(np.all(MAT @ MAT == lv.matrix(
 60        [[-1, 0],
 61         [0, -1]])
 62    ))
 63    print("A", DIAGa @ MAT)
 64    print("B", MAT @ DIAGa)
 65    print("C", MATa @ DIAG)
 66    print("D", DIAG @ MATa)
 67    print("E", DIAGa @ MATa)
 68    print("F", MATa @ DIAGa)
 69
 70    assert(np.all(DIAG @ MAT == lv.matrix(
 71        [[0, 2],
 72         [-4, 0]])
 73    ))
 74    assert(np.all(MAT @ DIAG == lv.matrix(
 75        [[0, 4],
 76         [-2, 0]])
 77    ))
 78
 79    print("G", DIAGa @ DIAG)
 80    print("H", DIAG @ DIAGa)
 81    assert(np.all(DIAG @ DIAG == lv.diagonal(
 82        [4, 16]
 83    )))
 84
 85    print("I", DIAGa @ SCALAR)
 86    print("J", SCALAR @ DIAGa)
 87    assert(np.all(DIAG @ SCALAR == lv.diagonal(
 88        [4, 8]
 89    )))
 90
 91    print("K", MATa @ SCALAR)
 92    print("L", SCALAR @ MATa)
 93    assert(np.all(MAT @ SCALAR == lv.matrix(
 94        [[0, 2],
 95         [-2, 0]])
 96    ))
 97
 98    print('++++++++++++++')
 99    # now the array style
100    print("A", MAT + MAT)
101    assert(np.all(MAT + MAT == lv.matrix(
102        [[0, 2],
103         [-2, 0]])
104    ))
105
106    print("B", DIAG + MAT)
107    assert(np.all(DIAG + MAT == lv.matrix(
108        [[2, 1],
109         [-1, 4]])
110    ))
111    print(MAT + DIAG)
112    assert(np.all(MAT + DIAG == lv.matrix(
113        [[2, 1],
114         [-1, 4]])
115    ))
116    print(DIAG + DIAG)
117    assert(np.all(DIAG + DIAG == lv.diagonal(
118        [4, 8]
119    )))
120
121    print(DIAG + SCALAR)
122    print(SCALAR + DIAG)
123    assert(np.all(DIAG + SCALAR == lv.diagonal(
124        [4, 6]
125    )))
126
127    print(MAT + SCALAR)
128    print(SCALAR + MAT)
129    assert(np.all(MAT + SCALAR == lv.matrix(
130        [[2, 1],
131         [-1, 2]])
132    ))
133
134    print('--------------')
135    # now the array style
136    print("A", MATa + MAT)
137    print("B", MAT + MATa)
138    print("C", MATa + MATa)
139    print("A", DIAGa + MAT)
140    print("B", MAT + DIAGa)
141    print("C", MATa + DIAG)
142    print("D", DIAG + MATa)
143    print("E", DIAGa + MATa)
144    print("F", MATa + DIAGa)
145
146    assert(np.all(DIAG + MATa == lv.matrix([
147        [(2, 2), (1, 1)],
148        [(-1, -1), (4, 5)]
149    ])))
150    assert(np.all(DIAGa + MAT == lv.matrix([
151        [(2, 2), (1, 1)],
152        [(-1, -1), (4, 5)]
153    ])))
154
155    print("G", DIAGa + DIAG)
156    print("H", DIAG + DIAGa)
157    assert(np.all(DIAGa + DIAG == lv.diagonal(
158        [(4, 4), (8, 9)]
159    )))
160    assert(np.all(DIAG + DIAGa == lv.diagonal(
161        [(4, 4), (8, 9)]
162    )))
163
164    print("I", DIAGa + SCALAR)
165    print("J", SCALAR + DIAGa)
166    assert(np.all(DIAGa + SCALAR == lv.diagonal(
167        [(4, 4), (6, 7)]
168    )))
169
170    print("K", MATa + SCALAR)
171    print("L", SCALAR + MATa)
172    assert(np.all(MATa + SCALAR == lv.matrix(
173        [[(2, 2), (1, 1)],
174         [(-1, -1), (2, 3)]])
175    ))
176    print("M", MAT + SCALARa)
177    print("N", SCALARa + MAT)
178    assert(np.all(MAT + SCALARa == lv.matrix(
179        [[(0, 1), (1, 1)],
180         [(-1, -1), (0, 1)]])
181    ))
pytest information

This code is wrapped in a pytest function using conventions detailed in Pytest Conventions. The full name of this test, as known by the documentation, is:

wield.control.linear_values.test.T_linear_values.T_linear_values

The full name is useful when building documentation, to link a reference to this page using :func:`name`, or directly include it with an autofunction directive. The collapse nodes below show every instance of the test run. There may only be one, but if the test was run multiple times through pytest parametrizations, the list can be longer.

T_linear_values
output
TEST [[[ 0  1]
  [-1  0]]

 [[ 0  1]
  [-1  1]]]
[[-1  0]
 [ 0 -1]]:(2,2)
[[ 0  2]
 [-4  0]]:(2,2)
[[ 0  4]
 [-2  0]]:(2,2)
[ 4 16]:d2
[4 8]:d2
[4 8]:d2
[[ 0  2]
 [-2  0]]:(2,2)
[[ 0  2]
 [-2  0]]:(2,2)
--------------
A [[[-1  0]
  [ 0 -1]]

 [[-1  0]
  [-1 -1]]]:(2,2)
B [[[-1  0]
  [ 0 -1]]

 [[-1  1]
  [ 0 -1]]]:(2,2)
C [[[-1  0]
  [ 0 -1]]

 [[-1  1]
  [-1  0]]]:(2,2)
A [[[ 0  2]
  [-4  0]]

 [[ 0  2]
  [-5  0]]]:(2,2)
B [[[ 0  4]
  [-2  0]]

 [[ 0  5]
  [-2  0]]]:(2,2)
C [[[ 0  4]
  [-2  0]]

 [[ 0  4]
  [-2  4]]]:(2,2)
D [[[ 0  2]
  [-4  0]]

 [[ 0  2]
  [-4  4]]]:(2,2)
E [[[ 0  2]
  [-4  0]]

 [[ 0  2]
  [-5  5]]]:(2,2)
F [[[ 0  4]
  [-2  0]]

 [[ 0  5]
  [-2  5]]]:(2,2)
G [[ 4 16]
 [ 4 20]]:d2
H [[ 4 16]
 [ 4 20]]:d2
I [[ 4  8]
 [ 4 10]]:d2
J [[ 4  8]
 [ 4 10]]:d2
K [[[ 0  2]
  [-2  0]]

 [[ 0  2]
  [-2  2]]]:(2,2)
L [[[ 0  2]
  [-2  0]]

 [[ 0  2]
  [-2  2]]]:(2,2)
++++++++++++++
A [[ 0  2]
 [-2  0]]:(2,2)
captured errors:
def T_linear_values():
        ZERO = lv.scalar(0)
        IDENT = lv.scalar(1)
        SCALAR = lv.scalar(2)
        SCALARa = lv.scalar(np.arange(2))

        DIAG = lv.diagonal([2, 4])
        DIAGa = lv.diagonal([2, 4 + np.arange(2)])

        MAT = lv.matrix(
            [[0, 1],
            [-1, 0]]
        )

        MATa = lv.matrix(
            [[0, 1],
            [-1, np.arange(2)]]
        )
        print("TEST", MATa.value)

        print(MAT @ MAT)
        assert(np.all(MAT @ MAT == lv.matrix(
            [[-1, 0],
             [0, -1]])
        ))
        print(DIAG @ MAT)
        assert(np.all(DIAG @ MAT == lv.matrix(
            [[0, 2],
             [-4, 0]])
        ))
        print(MAT @ DIAG)
        assert(np.all(MAT @ DIAG == lv.matrix(
            [[0, 4],
             [-2, 0]])
        ))
        print(DIAG @ DIAG)
        assert(np.all(DIAG @ DIAG == lv.diagonal(
            [4, 16]
        )))

        print(DIAG @ SCALAR)
        print(SCALAR @ DIAG)
        assert(np.all(DIAG @ SCALAR == lv.diagonal(
            [4, 8]
        )))

        print(MAT @ SCALAR)
        print(SCALAR @ MAT)
        assert(np.all(MAT @ SCALAR == lv.matrix(
            [[0, 2],
             [-2, 0]])
        ))

        print('--------------')
        # now the array style
        print("A", MATa @ MAT)
        print("B", MAT @ MATa)
        print("C", MATa @ MATa)
        assert(np.all(MAT @ MAT == lv.matrix(
            [[-1, 0],
             [0, -1]])
        ))
        print("A", DIAGa @ MAT)
        print("B", MAT @ DIAGa)
        print("C", MATa @ DIAG)
        print("D", DIAG @ MATa)
        print("E", DIAGa @ MATa)
        print("F", MATa @ DIAGa)

        assert(np.all(DIAG @ MAT == lv.matrix(
            [[0, 2],
             [-4, 0]])
        ))
        assert(np.all(MAT @ DIAG == lv.matrix(
            [[0, 4],
             [-2, 0]])
        ))

        print("G", DIAGa @ DIAG)
        print("H", DIAG @ DIAGa)
        assert(np.all(DIAG @ DIAG == lv.diagonal(
            [4, 16]
        )))

        print("I", DIAGa @ SCALAR)
        print("J", SCALAR @ DIAGa)
        assert(np.all(DIAG @ SCALAR == lv.diagonal(
            [4, 8]
        )))

        print("K", MATa @ SCALAR)
        print("L", SCALAR @ MATa)
        assert(np.all(MAT @ SCALAR == lv.matrix(
            [[0, 2],
             [-2, 0]])
        ))

        print('++++++++++++++')
        # now the array style
        print("A", MAT + MAT)
        assert(np.all(MAT + MAT == lv.matrix(
            [[0, 2],
             [-2, 0]])
        ))

>       print("B", DIAG + MAT)

../../src/wield/control/linear_values/test/T_linear_values.py:123: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../../src/wield/control/linear_values/linear_values.py:128: in __add__
    return self.matadd(other)
../../src/wield/control/linear_values/linear_values.py:192: in matadd
    subshape = broadcast_shapes([other.value.shape[:-2], self.value.shape[:-1]])
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

mlist = [(), ()]

    def broadcast_shapes(mlist):
        """
        Finds the common shape of a list of arrays, such that broadcasting into
        that shape will succeed.
        """
        # do a huge, deep broadcast of all values
        idx = 0
        bc = None
        while idx < len(mlist):
            if idx == 0 or bc == ():
                v = mlist[idx : idx + 32]
>               bc = np.broadcast_shapes(*[_.shape for _ in v])
E               AttributeError: 'tuple' object has no attribute 'shape'

/wield/wield-utilities/src/wield/utilities/np.py:441: AttributeError