def test_addition(self):
"""Linear operator addition."""
for A, B in list(zip(self.arrays, self.arrays)):
with self.subTest():
Aop = linops.Matrix(A)
Bop = linops.Matrix(B)
self.assertAllClose((Aop + Bop).todense(), A + B)
def setUp(self):
"""Resources for tests."""
# Seed
np.random.seed(seed=42)
# Parameters
m = 7
n = 3
self.constants = [-1, -2.4, 0, 200, np.pi]
sparsemat = scipy.sparse.rand(m=m, n=n, density=0.1, random_state=1)
self.normal_params = [
# Univariate
(-1.0, 3.0),
(1, 3),
# Multivariate
(np.random.uniform(size=10), np.eye(10)),
(np.random.uniform(size=10), random_spd_matrix(10)),
# Matrixvariate
(
np.random.uniform(size=(2, 2)),
linops.SymmetricKronecker(
A=np.array([[1.0, 2.0], [2.0, 1.0]]),
B=np.array([[5.0, -1.0], [-1.0, 10.0]]),
).todense(),
),
# Operatorvariate
(
np.array([1.0, -5.0]),
linops.Matrix(A=np.array([[2.0, 1.0], [1.0, -0.1]])),
),
(
linops.Matrix(A=np.array([[0.0, -5.0]])),
linops.Identity(shape=(2, 2)),
),
(
np.array([[1.0, 2.0], [-3.0, -0.4], [4.0, 1.0]]),
linops.Kronecker(A=np.eye(3), B=5 * np.eye(2)),
),
(
linops.Matrix(A=sparsemat.todense()),
linops.Kronecker(0.1 * linops.Identity(m), linops.Identity(n)),
),
(
linops.Matrix(A=np.random.uniform(size=(2, 2))),
linops.SymmetricKronecker(
A=np.array([[1.0, 2.0], [2.0, 1.0]]),
B=np.array([[5.0, -1.0], [-1.0, 10.0]]),
),
),
# Symmetric Kronecker Identical Factors
(
linops.Identity(shape=25),
linops.SymmetricKronecker(A=linops.Identity(25)),
),
]
def get_randvar(rv_name):
"""Return a random variable for a given distribution name."""
# Distribution Means and Covariances
mean_0d = np.random.rand()
mean_1d = np.random.rand(5)
mean_2d_mat = SPD_MATRIX_5x5
mean_2d_linop = linops.Matrix(SPD_MATRIX_5x5)
cov_0d = np.random.rand() + 10**-12
cov_1d = SPD_MATRIX_5x5
cov_2d_kron = linops.Kronecker(A=SPD_MATRIX_5x5, B=SPD_MATRIX_5x5)
cov_2d_symkron = linops.SymmetricKronecker(A=SPD_MATRIX_5x5)
if rv_name == "univar_normal":
randvar = rvs.Normal(mean=mean_0d, cov=cov_0d)
elif rv_name == "multivar_normal":
randvar = rvs.Normal(mean=mean_1d, cov=cov_1d)
elif rv_name == "matrixvar_normal":
randvar = rvs.Normal(mean=mean_2d_mat, cov=cov_2d_kron)
elif rv_name == "symmatrixvar_normal":
randvar = rvs.Normal(mean=mean_2d_mat, cov=cov_2d_symkron)
elif rv_name == "operatorvar_normal":
randvar = rvs.Normal(mean=mean_2d_linop, cov=cov_2d_symkron)
else:
raise ValueError("Random variable not found.")
return randvar
def setUp(self) -> None:
"""Scalars, arrays, linear operators and random variables for tests."""
# Seed
np.random.seed(42)
# Random variable instantiation
self.scalars = [0, int(1), 0.1, np.nan, np.inf]
self.arrays = [np.empty(2), np.zeros(4), np.array([]), np.array([1, 2])]
# Random variable arithmetic
self.arrays2d = [
np.empty(2),
np.zeros(2),
np.array([np.inf, 1]),
np.array([1, -2.5]),
]
self.matrices2d = [np.array([[1, 2], [3, 2]]), np.array([[0, 0], [1.0, -4.3]])]
self.linops2d = [linops.Matrix(A=np.array([[1, 2], [4, 5]]))]
self.randvars2d = [
randvars.Normal(mean=np.array([1, 2]), cov=np.array([[2, 0], [0, 5]]))
]
self.randvars2x2 = [
randvars.Normal(
mean=np.array([[-2, 0.3], [0, 1]]),
cov=linops.SymmetricKronecker(A=np.eye(2), B=np.ones((2, 2))),
),
]
self.scipyrvs = [
scipy.stats.bernoulli(0.75),
scipy.stats.norm(4, 2.4),
scipy.stats.multivariate_normal(np.random.randn(10), np.eye(10)),
scipy.stats.gamma(0.74),
scipy.stats.dirichlet(alpha=np.array([0.1, 0.1, 0.2, 0.3])),
]
def test_scalar_mult(self):
"""Matrix linear operator multiplication with scalars."""
for A, alpha in list(itertools.product(self.arrays, self.scalars)):
with self.subTest():
Aop = linops.Matrix(A)
self.assertAllClose((alpha * Aop).todense(), alpha * A)
def _drift_matrix(self):
drift_matrix_1d = np.diag(np.ones(self.num_derivatives), 1)
if config.matrix_free:
return linops.Kronecker(
A=linops.Identity(self.wiener_process_dimension),
B=linops.Matrix(A=drift_matrix_1d),
)
return np.kron(np.eye(self.wiener_process_dimension), drift_matrix_1d)
def _dispersion_matrix(self):
dispersion_matrix_1d = np.zeros(self.num_derivatives + 1)
dispersion_matrix_1d[-1] = 1.0 # Unit diffusion
if config.matrix_free:
return linops.Kronecker(
A=linops.Identity(self.wiener_process_dimension),
B=linops.Matrix(A=dispersion_matrix_1d.reshape(-1, 1)),
)
return np.kron(np.eye(self.wiener_process_dimension), dispersion_matrix_1d).T
def case_state_symmetric_matrix_based(rng: np.random.Generator, ):
"""State of a symmetric matrix-based linear solver."""
prior = linalg.solvers.beliefs.LinearSystemBelief(
A=randvars.Normal(
mean=linops.Matrix(linsys.A),
cov=linops.SymmetricKronecker(A=linops.Identity(n)),
),
x=(Ainv @ b[:, None]).reshape((n, )),
Ainv=randvars.Normal(
mean=linops.Identity(n),
cov=linops.SymmetricKronecker(A=linops.Identity(n)),
),
b=b,
)
state = linalg.solvers.LinearSolverState(problem=linsys, prior=prior)
state.action = rng.standard_normal(size=state.problem.A.shape[1])
state.observation = rng.standard_normal(size=state.problem.A.shape[1])
return state
