def matrix_pair(self, rng, size, size_inner):
left_factor_matrix = rng.standard_normal((size, size_inner))
right_factor_matrix = rng.standard_normal((size_inner, size))
inner_square_matrix = rng.standard_normal((size_inner, size_inner))
square_matrix = rng.standard_normal((size, size))
return (
matrices.SquareLowRankUpdateMatrix(
matrices.DenseRectangularMatrix(left_factor_matrix),
matrices.DenseRectangularMatrix(right_factor_matrix),
matrices.DenseSquareMatrix(square_matrix),
matrices.DenseSquareMatrix(inner_square_matrix),
),
square_matrix
+ left_factor_matrix @ (inner_square_matrix @ right_factor_matrix),
)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for sz in SIZES:
array = rng.standard_normal((sz, sz))
matrix_pairs[sz] = (matrices.DenseSquareMatrix(array), array)
super().__init__(matrix_pairs, rng)
def matrix_pair(self, rng, size, request):
n_terms = request.param
arrays = [rng.standard_normal((size, size)) for _ in range(n_terms)]
matrix = matrices.SquareMatrixProduct(
[matrices.DenseSquareMatrix(a) for a in arrays]
)
return matrix, nla.multi_dot(arrays)
def __init__(self):
super().__init__()
for sz in SIZES:
for transposed in [True, False]:
array = self.rng.standard_normal((sz, sz))
self.matrices[sz] = matrices.DenseSquareMatrix(
array, transposed)
self.np_matrices[sz] = array.T if transposed else array
def matrix_pair(self, rng, size, n_block):
blocks = [rng.standard_normal((size, size)) for _ in range(n_block)]
return (
matrices.BlockColumnMatrix(
matrices.DenseSquareMatrix(block) for block in blocks
),
np.vstack(blocks),
)
def matrix_pair(self, rng, size, n_block):
arrays = [rng.standard_normal((size, size)) for _ in range(n_block)]
return (
matrices.SquareBlockDiagonalMatrix(
matrices.DenseSquareMatrix(arr) for arr in arrays
),
sla.block_diag(*arrays),
)
def matrix_pair(self, rng, size, request):
n_terms, explicit = request.param
arrays = [rng.standard_normal((size, size)) for _ in range(n_terms)]
matrices_ = [matrices.DenseSquareMatrix(a) for a in arrays]
if explicit:
matrix = matrices.InvertibleMatrixProduct(matrices_)
else:
matrix = reduce(lambda a, b: a @ b, matrices_)
return matrix, nla.multi_dot(arrays)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for s in SIZES:
for n_blocks in [2, 5]:
blocks = [rng.standard_normal((s, s)) for _ in range(n_blocks)]
matrix_pairs[(s, n_blocks)] = (matrices.BlockColumnMatrix(
matrices.DenseSquareMatrix(block)
for block in blocks), np.vstack(blocks))
super().__init__(matrix_pairs, rng)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for s in SIZES:
for n_terms in [2, 5]:
arrays = [rng.standard_normal((s, s)) for _ in range(n_terms)]
matrix = matrices.SquareMatrixProduct(
[matrices.DenseSquareMatrix(a) for a in arrays])
matrix_pairs[(s, n_terms)] = (matrix, nla.multi_dot(arrays))
super().__init__(matrix_pairs, rng)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for s in SIZES:
for n_block in [1, 2, 5]:
arrays = [rng.standard_normal((s, s)) for _ in range(n_block)]
matrix_pairs[(s,
n_block)] = (matrices.SquareBlockDiagonalMatrix(
matrices.DenseSquareMatrix(arr)
for arr in arrays), sla.block_diag(*arrays))
super().__init__(matrix_pairs, rng)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for outer_dim in SIZES:
for inner_dim in [max(1, outer_dim // 2), max(1, outer_dim - 1)]:
left_factor_matrix = rng.standard_normal(
(outer_dim, inner_dim))
right_factor_matrix = rng.standard_normal(
(inner_dim, outer_dim))
inner_square_matrix = rng.standard_normal(
(inner_dim, inner_dim))
square_matrix = rng.standard_normal((outer_dim, outer_dim))
matrix_pairs[(inner_dim, outer_dim)] = (
matrices.SquareLowRankUpdateMatrix(
matrices.DenseRectangularMatrix(left_factor_matrix),
matrices.DenseRectangularMatrix(right_factor_matrix),
matrices.DenseSquareMatrix(square_matrix),
matrices.DenseSquareMatrix(inner_square_matrix)),
square_matrix + left_factor_matrix
@ (inner_square_matrix @ right_factor_matrix))
super().__init__(matrix_pairs, rng)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for s in SIZES:
for n_terms in [2, 5]:
for explicit in [True, False]:
arrays = [
rng.standard_normal((s, s)) for _ in range(n_terms)
]
matrices_ = [matrices.DenseSquareMatrix(a) for a in arrays]
if explicit:
matrix = matrices.InvertibleMatrixProduct(matrices_)
else:
matrix = reduce(lambda a, b: a @ b, matrices_)
matrix_pairs[(s, n_terms,
explicit)] = (matrix, nla.multi_dot(arrays))
super().__init__(matrix_pairs, rng)
def matrix_pair(self, rng, size):
array = rng.standard_normal((size, size))
return matrices.DenseSquareMatrix(array), array
