def test_fspace_simple_attributes():
intv = odl.IntervalProd(0, 1)
fspace = FunctionSpace(intv)
fspace_r = FunctionSpace(intv, field=odl.RealNumbers())
fspace_c = FunctionSpace(intv, field=odl.ComplexNumbers())
assert fspace.domain == intv
assert fspace.range == odl.RealNumbers()
assert fspace_r.range == odl.RealNumbers()
assert fspace_c.range == odl.ComplexNumbers()
def test_dspace_type_numpy():
# Plain function set -> Ntuples-like
fset = odl.FunctionSet(odl.Interval(0, 1), odl.Strings(2))
assert dspace_type(fset, 'numpy') == odl.Ntuples, None
assert dspace_type(fset, 'numpy', np.int) == odl.Ntuples
# Real space
rspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.RealNumbers())
assert dspace_type(rspc, 'numpy') == odl.Fn
assert dspace_type(rspc, 'numpy', np.float32) == odl.Fn
assert dspace_type(rspc, 'numpy', np.int) == odl.Fn
with pytest.raises(TypeError):
dspace_type(rspc, 'numpy', np.complex)
with pytest.raises(TypeError):
dspace_type(rspc, 'numpy', np.dtype('<U2'))
# Complex space
cspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.ComplexNumbers())
assert dspace_type(cspc, 'numpy') == odl.Fn
assert dspace_type(cspc, 'numpy', np.complex64) == odl.Fn
with pytest.raises(TypeError):
dspace_type(cspc, 'numpy', np.float)
with pytest.raises(TypeError):
assert dspace_type(cspc, 'numpy', np.int)
with pytest.raises(TypeError):
dspace_type(cspc, 'numpy', np.dtype('<U2'))
def test_uniform_discr_init_real(odl_tspace_impl):
"""Test initialization and basic properties with uniform_discr, real."""
impl = odl_tspace_impl
# 1D
discr = odl.uniform_discr(0, 1, 10, impl=impl)
assert isinstance(discr, DiscreteLp)
assert isinstance(discr.tspace, TensorSpace)
assert discr.impl == impl
assert discr.is_real
assert discr.tspace.exponent == 2.0
assert discr.dtype == discr.tspace.default_dtype(odl.RealNumbers())
assert discr.is_real
assert not discr.is_complex
assert all_equal(discr.min_pt, [0])
assert all_equal(discr.max_pt, [1])
assert discr.shape == (10, )
assert repr(discr)
discr = odl.uniform_discr(0, 1, 10, impl=impl, exponent=1.0)
assert discr.exponent == 1.0
# 2D
discr = odl.uniform_discr([0, 0], [1, 1], (5, 5))
assert all_equal(discr.min_pt, np.array([0, 0]))
assert all_equal(discr.max_pt, np.array([1, 1]))
assert discr.shape == (5, 5)
# nd
discr = odl.uniform_discr([0] * 10, [1] * 10, (5, ) * 10)
assert all_equal(discr.min_pt, np.zeros(10))
assert all_equal(discr.max_pt, np.ones(10))
assert discr.shape == (5, ) * 10
def test_dspace_type_cuda():
# Plain function set -> Ntuples-like
fset = odl.FunctionSet(odl.Interval(0, 1), odl.Strings(2))
assert dspace_type(fset, 'cuda') == odl.CudaNtuples
assert dspace_type(fset, 'cuda', np.int) == odl.CudaNtuples
# Real space
rspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.RealNumbers())
assert dspace_type(rspc, 'cuda') == odl.CudaFn
assert dspace_type(rspc, 'cuda', np.float64) == odl.CudaFn
assert dspace_type(rspc, 'cuda', np.int) == odl.CudaFn
with pytest.raises(TypeError):
dspace_type(rspc, 'cuda', np.complex)
with pytest.raises(TypeError):
dspace_type(rspc, 'cuda', np.dtype('<U2'))
# Complex space (not implemented)
cspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.ComplexNumbers())
with pytest.raises(NotImplementedError):
dspace_type(cspc, 'cuda')
with pytest.raises(NotImplementedError):
dspace_type(cspc, 'cuda', np.complex64)
with pytest.raises(TypeError):
dspace_type(cspc, 'cuda', np.float)
with pytest.raises(TypeError):
assert dspace_type(cspc, 'cuda', np.int)
def test_fspace_attributes():
"""Check attribute access and correct values."""
intv = odl.IntervalProd(0, 1)
# Scalar-valued function spaces
fspace = FunctionSpace(intv)
fspace_r = FunctionSpace(intv, out_dtype=float)
fspace_c = FunctionSpace(intv, out_dtype=complex)
fspace_s = FunctionSpace(intv, out_dtype='U1')
scalar_spaces = (fspace, fspace_r, fspace_c, fspace_s)
assert fspace.domain == intv
assert fspace.field == odl.RealNumbers()
assert fspace_r.field == odl.RealNumbers()
assert fspace_c.field == odl.ComplexNumbers()
assert fspace_s.field is None
assert fspace.out_dtype == float
assert fspace_r.out_dtype == float
assert fspace_r.real_out_dtype == float
assert fspace_r.complex_out_dtype == complex
assert fspace_c.out_dtype == complex
assert fspace_c.real_out_dtype == float
assert fspace_c.complex_out_dtype == complex
assert fspace_s.out_dtype == np.dtype('U1')
assert fspace.is_real
assert not fspace.is_complex
assert fspace_r.is_real
assert not fspace_r.is_complex
assert fspace_c.is_complex
assert not fspace_c.is_real
with pytest.raises(AttributeError):
fspace_s.real_out_dtype
with pytest.raises(AttributeError):
fspace_s.complex_out_dtype
assert all(spc.scalar_out_dtype == spc.out_dtype for spc in scalar_spaces)
assert all(spc.out_shape == () for spc in scalar_spaces)
assert all(not spc.tensor_valued for spc in scalar_spaces)
# Vector-valued function space
fspace_vec = FunctionSpace(intv, out_dtype=(float, (2, )))
assert fspace_vec.field == odl.RealNumbers()
assert fspace_vec.out_dtype == np.dtype((float, (2, )))
assert fspace_vec.scalar_out_dtype == float
assert fspace_vec.out_shape == (2, )
assert fspace_vec.tensor_valued
def test_factory_cuda(exponent):
discr = odl.uniform_discr(0, 1, 10, impl='cuda', exponent=exponent)
assert isinstance(discr.dspace, odl.CudaFn)
assert discr.is_rn
assert discr.dspace.exponent == exponent
assert discr.dtype == odl.CudaFn.default_dtype(odl.RealNumbers())
# Cuda currently does not support complex numbers, check error
with pytest.raises(NotImplementedError):
odl.uniform_discr(0, 1, 10, impl='cuda', dtype='complex')
def test_fspace_init():
intv = odl.IntervalProd(0, 1)
FunctionSpace(intv)
FunctionSpace(intv, field=odl.RealNumbers())
FunctionSpace(intv, field=odl.ComplexNumbers())
rect = odl.IntervalProd([0, 0], [1, 2])
FunctionSpace(rect)
FunctionSpace(rect, field=odl.RealNumbers())
FunctionSpace(rect, field=odl.ComplexNumbers())
cube = odl.IntervalProd([0, 0, 0], [1, 2, 3])
FunctionSpace(cube)
FunctionSpace(cube, field=odl.RealNumbers())
FunctionSpace(cube, field=odl.ComplexNumbers())
ndbox = odl.IntervalProd([0] * 10, np.arange(1, 11))
FunctionSpace(ndbox)
FunctionSpace(ndbox, field=odl.RealNumbers())
FunctionSpace(ndbox, field=odl.ComplexNumbers())
def test_fspace_equality():
intv = odl.Interval(0, 1)
intv2 = odl.Interval(-1, 1)
fspace = FunctionSpace(intv)
fspace_r = FunctionSpace(intv, field=odl.RealNumbers())
fspace_c = FunctionSpace(intv, field=odl.ComplexNumbers())
fspace_intv2 = FunctionSpace(intv2)
assert fspace == fspace_r
assert fspace != fspace_c
assert fspace != fspace_intv2
def test_emptyproduct():
with pytest.raises(ValueError):
odl.ProductSpace()
reals = odl.RealNumbers()
spc = odl.ProductSpace(field=reals)
assert spc.field == reals
assert spc.size == 0
with pytest.raises(IndexError):
spc[0]
def test_creation_of_vector_in_rn(self):
geom = Geometry(2)
rn = Rn(geom.proj_size)
self.assertEqual(type(rn).__name__, 'Rn')
rn_vec = rn.element(np.zeros(geom.proj_size))
self.assertEqual(type(rn_vec).__name__, 'Vector')
self.assertEqual(rn.dtype, 'float')
self.assertEqual(rn.field, odl.RealNumbers())
ODLChambollePock(geom)
def test_empty():
"""Check if empty spaces behave as expected and all methods work."""
discr = odl.uniform_discr([], [], ())
assert discr.axis_labels == ()
assert discr.tangent_bundle == odl.ProductSpace(field=odl.RealNumbers())
assert discr.complex_space == odl.uniform_discr([], [], (), dtype=complex)
hash(discr)
assert repr(discr) != ''
elem = discr.element(1.0)
assert np.array_equal(elem.asarray(), 1.0)
assert np.array_equal(elem.real, 1.0)
assert np.array_equal(elem.imag, 0.0)
assert np.array_equal(elem.conj(), 1.0)
def test_equals():
"""Test equality check and hash."""
intv = odl.IntervalProd(0, 1)
intv2 = odl.IntervalProd(-1, 1)
fspace = FunctionSpace(intv)
fspace_r = FunctionSpace(intv, field=odl.RealNumbers())
fspace_c = FunctionSpace(intv, field=odl.ComplexNumbers())
fspace_intv2 = FunctionSpace(intv2)
_test_eq(fspace, fspace)
_test_eq(fspace, fspace_r)
_test_eq(fspace_c, fspace_c)
_test_neq(fspace, fspace_c)
_test_neq(fspace, fspace_intv2)
def test_factory(exponent):
discr = odl.uniform_discr(0, 1, 10, impl='numpy', exponent=exponent)
assert isinstance(discr.dspace, odl.Fn)
assert discr.is_rn
assert discr.dspace.exponent == exponent
assert discr.dtype == odl.Fn.default_dtype(odl.RealNumbers())
# Complex
discr = odl.uniform_discr(0, 1, 10, dtype='complex',
impl='numpy', exponent=exponent)
assert isinstance(discr.dspace, odl.Fn)
assert discr.is_cn
assert discr.dspace.exponent == exponent
assert discr.dtype == odl.Fn.default_dtype(odl.ComplexNumbers())
def test_empty():
"""Check if empty spaces behave as expected and all methods work."""
discr = odl.uniform_discr([], [], ())
assert discr.interp == 'nearest'
assert discr.axis_labels == ()
assert discr.order == 'C'
assert discr.exponent == 2.0
assert discr.tangent_bundle == odl.ProductSpace(field=odl.RealNumbers())
assert discr.complex_space == odl.uniform_discr([], [], (), dtype=complex)
hash(discr)
repr(discr)
elem = discr.element()
assert np.array_equal(elem.asarray(), [])
assert np.array_equal(elem.real, [])
assert np.array_equal(elem.imag, [])
assert np.array_equal(elem.conj(), [])
def test_power_shape():
"""Check if shape and size are correct for higher-order power spaces."""
r2 = odl.rn(2)
r3 = odl.rn(3)
empty = odl.ProductSpace(field=odl.RealNumbers())
empty2 = odl.ProductSpace(r2, 0)
assert empty.shape == empty2.shape == ()
assert empty.size == empty2.size == 0
r2_3 = odl.ProductSpace(r2, 3)
_test_shape(r2_3, (3, 2))
r2xr3 = odl.ProductSpace(r2, r3)
_test_shape(r2xr3, (2,))
r2xr3_4 = odl.ProductSpace(r2xr3, 4)
_test_shape(r2xr3_4, (4, 2))
r2xr3_5_4 = odl.ProductSpace(r2xr3_4, 5)
_test_shape(r2xr3_5_4, (5, 4, 2))
def test_fourier_trafo_forward_complex(domain, impl):
if domain.field == odl.RealNumbers():
return
ft = odl.trafos.FourierTransform(domain, impl=impl)
def charfun_ball(x):
sum_sq = sum(xi ** 2 for xi in x)
return np.where(sum_sq < 1, 1, 0)
def charfun_freq_ball(x):
rad = np.max(ft.range.domain.extent / 4)
sum_sq = sum(xi ** 2 for xi in x)
return np.where(sum_sq < rad ** 2, 1, 0)
ball_dom = ft.domain.element(charfun_ball)
ball_ran = ft.range.element(charfun_freq_ball)
ball_dom_ft = ft(ball_dom)
ball_ran_ift = ft.adjoint(ball_ran)
assert almost_equal(ball_dom.inner(ball_ran_ift),
ball_ran.inner(ball_dom_ft), places=1)
def __init__(self):
super().__init__(odl.RealNumbers())
def __init__(self):
odl.LinearSpace.__init__(self, field=odl.RealNumbers())
def __init__(self, lie_group):
odl.LinearSpace.__init__(self, odl.RealNumbers())
self.lie_group = lie_group
def __init__(self):
super(Reals, self).__init__(field=odl.RealNumbers())
