status: failed
duration: 0.006s
Captured stdout call
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