def test_linear_scale():
A = np.random.rand(4, 3)
x = np.random.rand(3)
y = np.random.rand(4)
Aop = MatVecOperator(A)
xvec = Aop.domain.element(x)
yvec = Aop.range.element(y)
# Test a range of scalars (scalar multiplication could implement
# optimizations for (-1, 0, 1).
scalars = [-1.432, -1, 0, 1, 3.14]
for scale in scalars:
C = OperatorRightScalarMult(Aop, scale)
assert C.is_linear
assert C.adjoint.is_linear
assert all_almost_equal(C(xvec), scale * np.dot(A, x))
assert all_almost_equal(C.adjoint(yvec), scale * np.dot(A.T, y))
# Using operator overloading
assert all_almost_equal((scale * Aop)(xvec), scale * np.dot(A, x))
assert all_almost_equal((Aop * scale)(xvec), np.dot(A, scale * x))
assert all_almost_equal((scale * Aop).adjoint(yvec),
scale * np.dot(A.T, y))
assert all_almost_equal((Aop * scale).adjoint(yvec),
np.dot(A.T, scale * y))
def test_linear_adjoint():
A = np.random.rand(4, 3)
x = np.random.rand(4)
out = np.random.rand(3)
Aop = MatVecOperator(A)
xvec = Aop.range.element(x)
outvec = Aop.domain.element()
# Using inplace adjoint
Aop.adjoint(xvec, outvec)
np.dot(A.T, x, out)
assert all_almost_equal(out, outvec)
# Using out of place method
assert all_almost_equal(Aop.adjoint(xvec), np.dot(A.T, x))
def test_linear_adjoint():
A = np.random.rand(4, 3)
x = np.random.rand(4)
out = np.random.rand(3)
Aop = MatVecOperator(A)
xvec = Aop.range.element(x)
outvec = Aop.domain.element()
# Using inplace adjoint
Aop.adjoint(xvec, outvec)
np.dot(A.T, x, out)
assert all_almost_equal(out, outvec)
# Using out of place method
assert all_almost_equal(Aop.adjoint(xvec), np.dot(A.T, x))
def test_linear_composition():
A = np.random.rand(5, 4)
B = np.random.rand(4, 3)
x = np.random.rand(3)
y = np.random.rand(5)
Aop = MatVecOperator(A)
Bop = MatVecOperator(B)
xvec = Bop.domain.element(x)
yvec = Aop.range.element(y)
C = OperatorComp(Aop, Bop)
assert C.is_linear
assert C.adjoint.is_linear
assert all_almost_equal(C(xvec), np.dot(A, np.dot(B, x)))
assert all_almost_equal(C.adjoint(yvec), np.dot(B.T, np.dot(A.T, y)))
def test_linear_addition():
A = np.random.rand(4, 3)
B = np.random.rand(4, 3)
x = np.random.rand(3)
y = np.random.rand(4)
Aop = MatVecOperator(A)
Bop = MatVecOperator(B)
xvec = Aop.domain.element(x)
yvec = Aop.range.element(y)
# Explicit instantiation
C = OperatorSum(Aop, Bop)
assert C.is_linear
assert C.adjoint.is_linear
assert all_almost_equal(C(xvec), np.dot(A, x) + np.dot(B, x))
assert all_almost_equal(C.adjoint(yvec), np.dot(A.T, y) + np.dot(B.T, y))
# Using operator overloading
assert all_almost_equal((Aop + Bop)(xvec), np.dot(A, x) + np.dot(B, x))
assert all_almost_equal((Aop + Bop).adjoint(yvec),
np.dot(A.T, y) + np.dot(B.T, y))
def test_linear_op_nonsquare():
# Verify that the multiply op does indeed work as expected
A = np.random.rand(4, 3)
x = np.random.rand(3)
out = np.random.rand(4)
Aop = MatVecOperator(A)
xvec = Aop.domain.element(x)
outvec = Aop.range.element()
# Using out parameter
Aop(xvec, outvec)
np.dot(A, x, out)
assert all_almost_equal(out, outvec)
# Using return value
assert all_almost_equal(Aop(xvec), np.dot(A, x))
def test_linear_right_vector_mult():
A = np.random.rand(4, 3)
Aop = MatVecOperator(A)
vec = Aop.domain.element([1, 2, 3])
x = Aop.domain.element([4, 5, 6])
y = Aop.range.element([5, 6, 7, 8])
# Test a range of scalars (scalar multiplication could implement
# optimizations for (-1, 0, 1).
C = OperatorRightVectorMult(Aop, vec)
assert C.is_linear
assert C.adjoint.is_linear
assert all_almost_equal(C(x), np.dot(A, vec * x))
assert all_almost_equal(C.adjoint(y), vec * np.dot(A.T, y))
assert all_almost_equal(C.adjoint.adjoint(x), C(x))
# Using operator overloading
assert all_almost_equal((Aop * vec)(x), np.dot(A, vec * x))
assert all_almost_equal((Aop * vec).adjoint(y), vec * np.dot(A.T, y))
def test_type_errors():
r3 = odl.Rn(3)
r4 = odl.Rn(4)
Aop = MatVecOperator(np.random.rand(3, 3))
r3Vec1 = r3.zero()
r3Vec2 = r3.zero()
r4Vec1 = r4.zero()
r4Vec2 = r4.zero()
# Verify that correct usage works
Aop(r3Vec1, r3Vec2)
Aop.adjoint(r3Vec1, r3Vec2)
# Test that erroneous usage raises TypeError
with pytest.raises(OpDomainError):
Aop(r4Vec1)
with pytest.raises(OpDomainError):
Aop.adjoint(r4Vec1)
with pytest.raises(OpRangeError):
Aop(r3Vec1, r4Vec1)
with pytest.raises(OpRangeError):
Aop.adjoint(r3Vec1, r4Vec1)
with pytest.raises(OpDomainError):
Aop(r4Vec1, r3Vec1)
with pytest.raises(OpDomainError):
Aop.adjoint(r4Vec1, r3Vec1)
with pytest.raises(OpDomainError):
Aop(r4Vec1, r4Vec2)
with pytest.raises(OpDomainError):
Aop.adjoint(r4Vec1, r4Vec2)
def test_type_errors():
r3 = odl.Rn(3)
r4 = odl.Rn(4)
Aop = MatVecOperator(np.random.rand(3, 3))
r3Vec1 = r3.zero()
r3Vec2 = r3.zero()
r4Vec1 = r4.zero()
r4Vec2 = r4.zero()
# Verify that correct usage works
Aop(r3Vec1, r3Vec2)
Aop.adjoint(r3Vec1, r3Vec2)
# Test that erroneous usage raises TypeError
with pytest.raises(OpDomainError):
Aop(r4Vec1)
with pytest.raises(OpDomainError):
Aop.adjoint(r4Vec1)
with pytest.raises(OpRangeError):
Aop(r3Vec1, r4Vec1)
with pytest.raises(OpRangeError):
Aop.adjoint(r3Vec1, r4Vec1)
with pytest.raises(OpDomainError):
Aop(r4Vec1, r3Vec1)
with pytest.raises(OpDomainError):
Aop.adjoint(r4Vec1, r3Vec1)
with pytest.raises(OpDomainError):
Aop(r4Vec1, r4Vec2)
with pytest.raises(OpDomainError):
Aop.adjoint(r4Vec1, r4Vec2)