def test_nearest_interpolation_2d_string():
rect = odl.Rectangle([0, 0], [1, 1])
part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False)
# Coordinate vectors are:
# [0.125, 0.375, 0.625, 0.875], [0.25, 0.75]
space = odl.FunctionSet(rect, odl.Strings(1))
dspace = odl.Ntuples(part.size, dtype='U1')
interp_op = NearestInterpolation(space, part, dspace)
values = np.array([c for c in 'mystring'])
function = interp_op(values)
# Evaluate at single point
val = function([0.3, 0.6]) # closest to index (1, 1) -> 3
assert val == 't'
# Input array, with and without output array
pts = np.array([[0.3, 0.6], [1.0, 1.0]])
true_arr = ['t', 'g']
assert all_equal(function(pts.T), true_arr)
out = np.empty(2, dtype='U1')
function(pts.T, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0])
# Indices: (1, 3) x (0, 1)
true_mg = [['s', 't'], ['n', 'g']]
assert all_equal(function(mg), true_mg)
out = np.empty((2, 2), dtype='U1')
function(mg, out=out)
assert all_equal(out, true_mg)
def test_pointwise_inner_init_properties():
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2))
vfspace = ProductSpace(fspace, 3, exponent=2)
# Make sure the code runs and test the properties
pwinner = PointwiseInner(vfspace, vfspace.one())
assert pwinner.base_space == fspace
assert all_equal(pwinner.weights, [1, 1, 1])
assert not pwinner.is_weighted
repr(pwinner)
pwinner = PointwiseInner(vfspace, vfspace.one(), weight=[1, 2, 3])
assert all_equal(pwinner.weights, [1, 2, 3])
assert pwinner.is_weighted
# Bad input
with pytest.raises(TypeError):
PointwiseInner(odl.Rn(3), odl.Rn(3).one()) # No power space
# TODO: Does not raise currently, although bad_vecfield not in vfspace!
"""
bad_vecfield = ProductSpace(fspace, 3, exponent=1).one()
with pytest.raises(TypeError):
PointwiseInner(vfspace, bad_vecfield)
"""
with pytest.raises(ValueError):
PointwiseInner(vfspace, vfspace.one(), weight=-1) # < 0 not allowed
with pytest.raises(ValueError):
PointwiseInner(vfspace, vfspace.one(), weight=[1, 0, 1]) # 0 invalid
def test_nearest_interpolation_1d_complex():
"""Test nearest neighbor interpolation in 1d with complex values."""
coord_vecs = [[0.1, 0.3, 0.5, 0.7, 0.9]]
f = np.array([0 + 1j, 1 + 2j, 2 + 3j, 3 + 4j, 4 + 5j], dtype="complex128")
interpolator = nearest_interpolator(f, coord_vecs)
# Evaluate at single point
val = interpolator(0.35) # closest to index 1 -> 1 + 2j
assert val == 1.0 + 2.0j
# Input array, with and without output array
pts = np.array([0.39, 0.0, 0.65, 0.95])
true_arr = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j]
assert all_equal(interpolator(pts), true_arr)
# Should also work with a (1, N) array
pts = pts[None, :]
assert all_equal(interpolator(pts), true_arr)
out = np.empty(4, dtype='complex128')
interpolator(pts, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
# Same as array for 1d
mg = sparse_meshgrid([0.39, 0.0, 0.65, 0.95])
true_mg = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j]
assert all_equal(interpolator(mg), true_mg)
interpolator(mg, out=out)
assert all_equal(out, true_mg)
def test_nearest_interpolation_2d_float():
"""Test nearest neighbor interpolation in 2d."""
rect = odl.IntervalProd([0, 0], [1, 1])
part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False)
# Coordinate vectors are:
# [0.125, 0.375, 0.625, 0.875], [0.25, 0.75]
fspace = odl.FunctionSpace(rect)
tspace = odl.rn(part.shape)
interp_op = NearestInterpolation(fspace, part, tspace)
function = interp_op(np.reshape([0, 1, 2, 3, 4, 5, 6, 7], part.shape))
# Evaluate at single point
val = function([0.3, 0.6]) # closest to index (1, 1) -> 3
assert val == 3.0
# Input array, with and without output array
pts = np.array([[0.3, 0.6], [1.0, 1.0]])
true_arr = [3, 7]
assert all_equal(function(pts.T), true_arr)
out = np.empty(2, dtype='float64')
function(pts.T, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0])
# Indices: (1, 3) x (0, 1)
true_mg = [[2, 3], [6, 7]]
assert all_equal(function(mg), true_mg)
out = np.empty((2, 2), dtype='float64')
function(mg, out=out)
assert all_equal(out, true_mg)
assert repr(interp_op) != ''
def test_pointwise_inner_init_properties():
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2))
vfspace = ProductSpace(fspace, 3, exponent=2)
# Make sure the code runs and test the properties
pwinner = PointwiseInner(vfspace, vfspace.one())
assert pwinner.base_space == fspace
assert all_equal(pwinner.weights, [1, 1, 1])
assert not pwinner.is_weighted
repr(pwinner)
pwinner = PointwiseInner(vfspace, vfspace.one(), weight=[1, 2, 3])
assert all_equal(pwinner.weights, [1, 2, 3])
assert pwinner.is_weighted
# Bad input
with pytest.raises(TypeError):
PointwiseInner(odl.Rn(3), odl.Rn(3).one()) # No power space
# TODO: Does not raise currently, although bad_vecfield not in vfspace!
"""
bad_vecfield = ProductSpace(fspace, 3, exponent=1).one()
with pytest.raises(TypeError):
PointwiseInner(vfspace, bad_vecfield)
"""
with pytest.raises(ValueError):
PointwiseInner(vfspace, vfspace.one(), weight=-1) # < 0 not allowed
with pytest.raises(ValueError):
PointwiseInner(vfspace, vfspace.one(), weight=[1, 0, 1]) # 0 invalid
def test_asarray_2d():
discr_F = odl.uniform_discr([0, 0], [1, 1], [2, 2], order='F')
elem_F = discr_F.element([[1, 2], [3, 4]])
# Verify that returned array equals input data
assert all_equal(elem_F.asarray(), [[1, 2], [3, 4]])
# Check order of out array
assert elem_F.asarray().flags['F_CONTIGUOUS']
# test out parameter
out_F = np.asfortranarray(np.empty([2, 2]))
result_F = elem_F.asarray(out=out_F)
assert result_F is out_F
assert all_equal(out_F, [[1, 2], [3, 4]])
# Try discontinuous
out_F_wrong = np.asfortranarray(np.empty([2, 2]))[::2, :]
with pytest.raises(ValueError):
result_F = elem_F.asarray(out=out_F_wrong)
# Try wrong shape
out_F_wrong = np.asfortranarray(np.empty([2, 3]))
with pytest.raises(ValueError):
result_F = elem_F.asarray(out=out_F_wrong)
# Try wrong order
out_F_wrong = np.empty([2, 2])
with pytest.raises(ValueError):
elem_F.asarray(out=out_F_wrong)
# Also check with C ordering
discr_C = odl.uniform_discr([0, 0], [1, 1], (2, 2), order='C')
elem_C = discr_C.element([[1, 2], [3, 4]])
# Verify that returned array equals input data
assert all_equal(elem_C.asarray(), [[1, 2], [3, 4]])
# Check order of out array
assert elem_C.asarray().flags['C_CONTIGUOUS']
# test out parameter
out_C = np.empty([2, 2])
result_C = elem_C.asarray(out=out_C)
assert result_C is out_C
assert all_equal(out_C, [[1, 2], [3, 4]])
# Try discontinuous
out_C_wrong = np.empty([4, 2])[::2, :]
with pytest.raises(ValueError):
result_C = elem_C.asarray(out=out_C_wrong)
# Try wrong shape
out_C_wrong = np.empty([2, 3])
with pytest.raises(ValueError):
result_C = elem_C.asarray(out=out_C_wrong)
# Try wrong order
out_C_wrong = np.asfortranarray(np.empty([2, 2]))
with pytest.raises(ValueError):
elem_C.asarray(out=out_C_wrong)
def test_element_setitem_fancy():
"""Test assignment of pspace parts with lists."""
pspace = odl.ProductSpace(odl.rn(1), odl.rn(2), odl.rn(3))
x0 = pspace[0].element([0])
x1 = pspace[1].element([1, 2])
x2 = pspace[2].element([3, 4, 5])
x = pspace.element([x0, x1, x2])
old_x0 = x[0]
old_x2 = x[2]
# Check that values are set, but identity is preserved
new_x0 = pspace[0].element([6])
new_x2 = pspace[2].element([7, 8, 9])
x[[0, 2]] = pspace[[0, 2]].element([new_x0, new_x2])
assert x[[0, 2]][0] is old_x0
assert x[[0, 2]][0] == new_x0
assert x[[0, 2]][1] is old_x2
assert x[[0, 2]][1] == new_x2
# Set values with sequences of scalars
x[[0, 2]] = [-1, -2]
assert x[[0, 2]][0] is old_x0
assert all_equal(x[[0, 2]][0], [-1])
assert x[[0, 2]][1] is old_x2
assert all_equal(x[[0, 2]][1], [-2, -2, -2])
def test_element_getitem_multi():
"""Test element access with multiple indices."""
pspace = odl.ProductSpace(odl.rn(1), odl.rn(2))
pspace2 = odl.ProductSpace(pspace, 3)
pspace3 = odl.ProductSpace(pspace2, 2)
z = pspace3.element(
[[[[1],
[2, 3]],
[[4],
[5, 6]],
[[7],
[8, 9]]],
[[[10],
[12, 13]],
[[14],
[15, 16]],
[[17],
[18, 19]]]
]
)
assert pspace3.shape == (2, 3, 2)
assert z[0, 0, 0, 0] == 1
assert all_equal(z[0, 0, 1], [2, 3])
assert all_equal(z[0, 0], [[1], [2, 3]])
assert all_equal(z[0, 1:], [[[4],
[5, 6]],
[[7],
[8, 9]]])
assert all_equal(z[0, 1:, 1], [[5, 6],
[8, 9]])
assert all_equal(z[0, 1:, :, 0], [[[4],
[5]],
[[7],
[8]]])
def test_nearest_interpolation_1d_variants():
intv = odl.Interval(0, 1)
part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False)
# Coordinate vectors are:
# [0.1, 0.3, 0.5, 0.7, 0.9]
space = odl.FunctionSpace(intv)
dspace = odl.Rn(part.size)
# 'left' variant
interp_op = NearestInterpolation(space, part, dspace, variant='left')
function = interp_op([0, 1, 2, 3, 4])
# Testing two midpoints and the extreme values
pts = np.array([0.4, 0.8, 0.0, 1.0])
true_arr = [1, 3, 0, 4]
assert all_equal(function(pts), true_arr)
# 'right' variant
interp_op = NearestInterpolation(space, part, dspace, variant='right')
function = interp_op([0, 1, 2, 3, 4])
# Testing two midpoints and the extreme values
pts = np.array([0.4, 0.8, 0.0, 1.0])
true_arr = [2, 4, 0, 4]
assert all_equal(function(pts), true_arr)
def test_vectorize_callable_class():
# Test vectorization in 1d without data type --> lazy vectorization
arr = [[-2, -1, 0, 1, 2]]
mg = [[-3, -2, -1, 0, 1]]
val_1 = -1
val_2 = 2
# Class with __call__ method
class CallableClass(object):
def __call__(self, x):
return 0 if x < 0 else 1
vectorized_call = vectorize(CallableClass())
true_result_arr = [0, 0, 1, 1, 1]
true_result_mg = [0, 0, 0, 1, 1]
# Out-of-place
out = vectorized_call(arr)
assert isinstance(out, np.ndarray)
assert is_int_dtype(out.dtype)
assert out.shape == (5, )
assert all_equal(out, true_result_arr)
out = vectorized_call(mg)
assert isinstance(out, np.ndarray)
assert out.shape == (5, )
assert is_int_dtype(out.dtype)
assert all_equal(out, true_result_mg)
assert vectorized_call(val_1) == 0
assert vectorized_call(val_2) == 1
def test_nearest_interpolation_2d_float():
rect = odl.Rectangle([0, 0], [1, 1])
grid = odl.uniform_sampling(rect, [4, 2], as_midp=True)
# Coordinate vectors are:
# [0.125, 0.375, 0.625, 0.875], [0.25, 0.75]
space = odl.FunctionSpace(rect)
dspace = odl.Rn(grid.ntotal)
interp_op = NearestInterpolation(space, grid, dspace)
function = interp_op([0, 1, 2, 3, 4, 5, 6, 7])
# Evaluate at single point
val = function([0.3, 0.6]) # closest to index (1, 1) -> 3
assert val == 3.0
# Input array, with and without output array
pts = np.array([[0.3, 0.6],
[1.0, 1.0]])
true_arr = [3, 7]
assert all_equal(function(pts.T), true_arr)
out = np.empty(2, dtype='float64')
function(pts.T, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0])
# Indices: (1, 3) x (0, 1)
true_mg = [[2, 3],
[6, 7]]
assert all_equal(function(mg), true_mg)
out = np.empty((2, 2), dtype='float64')
function(mg, out=out)
assert all_equal(out, true_mg)
def test_asarray_2d(odl_elem_order):
"""Test the asarray method."""
order = odl_elem_order
discr = odl.uniform_discr([0, 0], [1, 1], [2, 2])
elem = discr.element([[1, 2], [3, 4]], order=order)
arr = elem.asarray()
assert all_equal(arr, [[1, 2], [3, 4]])
if order is None:
assert arr.flags[discr.default_order + '_CONTIGUOUS']
else:
assert arr.flags[order + '_CONTIGUOUS']
# test out parameter
out_c = np.empty([2, 2], order='C')
result_c = elem.asarray(out=out_c)
assert result_c is out_c
assert all_equal(out_c, [[1, 2], [3, 4]])
out_f = np.empty([2, 2], order='F')
result_f = elem.asarray(out=out_f)
assert result_f is out_f
assert all_equal(out_f, [[1, 2], [3, 4]])
# Try wrong shape
out_wrong_shape = np.empty([2, 3])
with pytest.raises(ValueError):
elem.asarray(out=out_wrong_shape)
def test_discrete_gradient_cuda():
"""Discretized spatial gradient operator using CUDA."""
# Check result of operator with explicit summation
# phantom data
data = np.array([[0., 1., 2., 3., 4.],
[1., 2., 3., 4., 5.],
[2., 3., 4., 5., 6.]])
# DiscreteLp Vector
discr_space = uniform_discr([0, 0], [6, 2.5], data.shape, impl='cuda')
dom_vec = discr_space.element(data)
# computation of gradient components with helper function
dx0, dx1 = discr_space.grid.stride
df0 = finite_diff(data, axis=0, dx=dx0, zero_padding=True, edge_order=2)
df1 = finite_diff(data, axis=1, dx=dx1, zero_padding=True, edge_order=2)
# gradient
grad = DiscreteGradient(discr_space)
grad_vec = grad(dom_vec)
assert len(grad_vec) == data.ndim
assert all_equal(grad_vec[0].asarray(), df0)
assert all_equal(grad_vec[1].asarray(), df1)
# adjoint operator
ran_vec = grad.range.element([data, data ** 2])
adj_vec = grad.adjoint(ran_vec)
lhs = ran_vec.inner(grad_vec)
rhs = dom_vec.inner(adj_vec)
assert lhs != 0
assert rhs != 0
assert lhs == rhs
def test_cell_sizes():
vec1 = np.array([1, 3])
vec2 = np.array([-1, 0, 1])
vec3 = np.array([2, 4, 5, 10])
scalar = 0.5
cs1, cs2, cs3 = [np.diff(vec) for vec in (vec1, vec2, vec3)]
csscal = 0
# Grid as set
grid = TensorGrid(vec1, vec2, vec3, as_midp=False)
assert all_equal(grid.cell_sizes(), (cs1, cs2, cs3))
grid = TensorGrid(vec1, scalar, vec3, as_midp=False)
assert all_equal(grid.cell_sizes(), (cs1, csscal, cs3))
# Grid as tesselation
cs1 = (2, 2)
cs2 = (1, 1, 1)
cs3 = (2, 1.5, 3, 5)
grid = TensorGrid(vec1, vec2, vec3, as_midp=True)
assert all_equal(grid.cell_sizes(), (cs1, cs2, cs3))
grid = TensorGrid(vec1, scalar, vec3, as_midp=True)
assert all_equal(grid.cell_sizes(), (cs1, csscal, cs3))
def test_element_from_array_2d():
# assert orderings work properly with 2d
discr = odl.uniform_discr([0, 0], [1, 1], [2, 2], impl='numpy', order='C')
vec = discr.element([[1, 2],
[3, 4]])
assert isinstance(vec, odl.DiscreteLpVector)
assert isinstance(vec.ntuple, odl.FnVector)
# Check ordering
assert all_equal(vec.ntuple, [1, 2, 3, 4])
# Linear creation works as well
linear_vec = discr.element([1, 2, 3, 4])
assert all_equal(vec.ntuple, [1, 2, 3, 4])
# Fortran order
discr = odl.uniform_discr([0, 0], [1, 1], (2, 2), impl='numpy', order='F')
vec = discr.element([[1, 2],
[3, 4]])
# Check ordering
assert all_equal(vec.ntuple, [1, 3, 2, 4])
# Linear creation works aswell
linear_vec = discr.element([1, 2, 3, 4])
assert all_equal(linear_vec.ntuple, [1, 2, 3, 4])
def test_nearest_interpolation_1d_variants():
"""Test nearest neighbor interpolation variants in 1d."""
intv = odl.IntervalProd(0, 1)
part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False)
# Coordinate vectors are:
# [0.1, 0.3, 0.5, 0.7, 0.9]
fspace = odl.FunctionSpace(intv)
tspace = odl.rn(part.shape)
# 'left' variant
interp_op = NearestInterpolation(fspace, part, tspace, variant='left')
assert repr(interp_op) != ''
function = interp_op([0, 1, 2, 3, 4])
# Testing two midpoints and the extreme values
pts = np.array([0.4, 0.8, 0.0, 1.0])
true_arr = [1, 3, 0, 4]
assert all_equal(function(pts), true_arr)
# 'right' variant
interp_op = NearestInterpolation(fspace, part, tspace, variant='right')
assert repr(interp_op) != ''
function = interp_op([0, 1, 2, 3, 4])
# Testing two midpoints and the extreme values
pts = np.array([0.4, 0.8, 0.0, 1.0])
true_arr = [2, 4, 0, 4]
assert all_equal(function(pts), true_arr)
def test_nearest_interpolation_1d_complex():
intv = odl.Interval(0, 1)
grid = odl.uniform_sampling(intv, 5, as_midp=True)
# Coordinate vectors are:
# [0.1, 0.3, 0.5, 0.7, 0.9]
space = odl.FunctionSpace(intv, field=odl.ComplexNumbers())
dspace = odl.Cn(grid.ntotal)
interp_op = NearestInterpolation(space, grid, dspace)
function = interp_op([0 + 1j, 1 + 2j, 2 + 3j, 3 + 4j, 4 + 5j])
# Evaluate at single point
val = function(0.35) # closest to index 1 -> 1 + 2j
assert val == 1.0 + 2.0j
# Input array, with and without output array
pts = np.array([0.4, 0.0, 0.65, 0.95])
true_arr = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j]
assert all_equal(function(pts), true_arr)
# Should also work with a (1, N) array
pts = pts[None, :]
assert all_equal(function(pts), true_arr)
out = np.empty(4, dtype='complex128')
function(pts, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
# Same as array for 1d
mg = sparse_meshgrid([0.4, 0.0, 0.65, 0.95])
true_mg = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j]
assert all_equal(function(mg), true_mg)
function(mg, out=out)
assert all_equal(out, true_mg)
def test_nearest_interpolation_1d_variants():
intv = odl.IntervalProd(0, 1)
part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False)
# Coordinate vectors are:
# [0.1, 0.3, 0.5, 0.7, 0.9]
space = odl.FunctionSpace(intv)
dspace = odl.rn(part.size)
# 'left' variant
interp_op = NearestInterpolation(space, part, dspace, variant='left')
function = interp_op([0, 1, 2, 3, 4])
# Testing two midpoints and the extreme values
pts = np.array([0.4, 0.8, 0.0, 1.0])
true_arr = [1, 3, 0, 4]
assert all_equal(function(pts), true_arr)
# 'right' variant
interp_op = NearestInterpolation(space, part, dspace, variant='right')
function = interp_op([0, 1, 2, 3, 4])
# Testing two midpoints and the extreme values
pts = np.array([0.4, 0.8, 0.0, 1.0])
true_arr = [2, 4, 0, 4]
assert all_equal(function(pts), true_arr)
def test_nearest_interpolation_2d_string():
"""Test nearest neighbor interpolation in 2d with string values."""
rect = odl.IntervalProd([0, 0], [1, 1])
part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False)
# Coordinate vectors are:
# [0.125, 0.375, 0.625, 0.875], [0.25, 0.75]
fspace = odl.FunctionSpace(rect, out_dtype='U1')
tspace = odl.tensor_space(part.shape, dtype='U1')
interp_op = NearestInterpolation(fspace, part, tspace)
values = np.array([c for c in 'mystring']).reshape(tspace.shape)
function = interp_op(values)
# Evaluate at single point
val = function([0.3, 0.6]) # closest to index (1, 1) -> 3
assert val == 't'
# Input array, with and without output array
pts = np.array([[0.3, 0.6], [1.0, 1.0]])
true_arr = ['t', 'g']
assert all_equal(function(pts.T), true_arr)
out = np.empty(2, dtype='U1')
function(pts.T, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0])
# Indices: (1, 3) x (0, 1)
true_mg = [['s', 't'], ['n', 'g']]
assert all_equal(function(mg), true_mg)
out = np.empty((2, 2), dtype='U1')
function(mg, out=out)
assert all_equal(out, true_mg)
assert repr(interp_op) != ''
def test_sparse_meshgrid():
# One array only
x = np.zeros(2)
true_mg = (x,)
assert all_equal(sparse_meshgrid(x), true_mg)
x = np.zeros((2, 2))
true_mg = (x,)
assert all_equal(sparse_meshgrid(x), true_mg)
# Two arrays, 'C' ordering
x, y = np.zeros(2), np.zeros(3)
true_mg = (x[:, None], y[None, :])
mg = sparse_meshgrid(x, y, order='C')
assert all_equal(mg, true_mg)
assert all(vec.flags.c_contiguous for vec in mg)
# Two arrays, 'F' ordering
x, y = np.zeros(2), np.zeros(3)
true_mg = (y[None, :], x[:, None])
mg = sparse_meshgrid(x, y, order='F')
assert all_equal(mg, true_mg)
assert all(vec.flags.f_contiguous for vec in mg)
# Array-like input
x, y = [1, 2, 3], [4, 5, 6]
true_mg = (np.array(x)[:, None], np.array(y)[None, :])
mg = sparse_meshgrid(x, y, order='C')
assert all_equal(mg, true_mg)
assert all(vec.flags.c_contiguous for vec in mg)
def test_nearest_interpolation_1d_complex(odl_tspace_impl):
"""Test nearest neighbor interpolation in 1d with complex values."""
impl = odl_tspace_impl # TODO: not used!
intv = odl.IntervalProd(0, 1)
part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False)
# Coordinate vectors are:
# [0.1, 0.3, 0.5, 0.7, 0.9]
fspace = odl.FunctionSpace(intv, out_dtype=complex)
tspace = odl.cn(part.shape)
interp_op = NearestInterpolation(fspace, part, tspace)
function = interp_op([0 + 1j, 1 + 2j, 2 + 3j, 3 + 4j, 4 + 5j])
# Evaluate at single point
val = function(0.35) # closest to index 1 -> 1 + 2j
assert val == 1.0 + 2.0j
# Input array, with and without output array
pts = np.array([0.4, 0.0, 0.65, 0.95])
true_arr = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j]
assert all_equal(function(pts), true_arr)
# Should also work with a (1, N) array
pts = pts[None, :]
assert all_equal(function(pts), true_arr)
out = np.empty(4, dtype='complex128')
function(pts, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
# Same as array for 1d
mg = sparse_meshgrid([0.4, 0.0, 0.65, 0.95])
true_mg = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j]
assert all_equal(function(mg), true_mg)
function(mg, out=out)
assert all_equal(out, true_mg)
assert repr(interp_op) != ''
def test_element_from_array_2d():
# assert orderings work properly with 2d
square_space = odl.FunctionSpace(odl.Rectangle([0, 0], [1, 1]))
discr = odl.uniform_discr(square_space, (2, 2), impl='numpy', order='C')
vec = discr.element([[1, 2],
[3, 4]])
assert isinstance(vec, discr.Vector)
assert isinstance(vec.ntuple, odl.Rn.Vector)
# Check ordering
assert all_equal(vec.ntuple, [1, 2, 3, 4])
# Linear creation works as well
linear_vec = discr.element([1, 2, 3, 4])
assert all_equal(vec.ntuple, [1, 2, 3, 4])
# Fortran order
discr = odl.uniform_discr(square_space, (2, 2), impl='numpy', order='F')
vec = discr.element([[1, 2],
[3, 4]])
# Check ordering
assert all_equal(vec.ntuple, [1, 3, 2, 4])
# Linear creation works aswell
linear_vec = discr.element([1, 2, 3, 4])
assert all_equal(linear_vec.ntuple, [1, 2, 3, 4])
def test_vectorize_2d_lazy():
# Test vectorization in 1d without data type --> lazy vectorization
arr = np.empty((2, 5), dtype='int')
arr[0] = ([-3, -2, -1, 0, 1])
arr[1] = ([-1, 0, 1, 2, 3])
mg = sparse_meshgrid([-3, -2, -1, 0, 1], [-1, 0, 1, 2, 3])
val_1 = (-1, 1)
val_2 = (2, 1)
@vectorize
def simple_func(x):
return 0 if x[0] < 0 and x[1] > 0 else 1
true_result_arr = [1, 1, 0, 1, 1]
true_result_mg = [[1, 1, 0, 0, 0], [1, 1, 0, 0, 0], [1, 1, 0, 0, 0],
[1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]
# Out-of-place
out = simple_func(arr)
assert isinstance(out, np.ndarray)
assert is_int_dtype(out.dtype)
assert out.shape == (5, )
assert all_equal(out, true_result_arr)
out = simple_func(mg)
assert isinstance(out, np.ndarray)
assert is_int_dtype(out.dtype)
assert out.shape == (5, 5)
assert all_equal(out, true_result_mg)
assert simple_func(val_1) == 0
assert simple_func(val_2) == 1
def test_nearest_interpolation_2d_string():
rect = odl.Rectangle([0, 0], [1, 1])
grid = odl.uniform_sampling(rect, [4, 2], as_midp=True)
# Coordinate vectors are:
# [0.125, 0.375, 0.625, 0.875], [0.25, 0.75]
space = odl.FunctionSet(rect, odl.Strings(1))
dspace = odl.Ntuples(grid.ntotal, dtype='U1')
interp_op = NearestInterpolation(space, grid, dspace)
values = np.array([c for c in 'mystring'])
function = interp_op(values)
# Evaluate at single point
val = function([0.3, 0.6]) # closest to index (1, 1) -> 3
assert val == 't'
# Input array, with and without output array
pts = np.array([[0.3, 0.6],
[1.0, 1.0]])
true_arr = ['t', 'g']
assert all_equal(function(pts.T), true_arr)
out = np.empty(2, dtype='U1')
function(pts.T, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0])
# Indices: (1, 3) x (0, 1)
true_mg = [['s', 't'],
['n', 'g']]
assert all_equal(function(mg), true_mg)
out = np.empty((2, 2), dtype='U1')
function(mg, out=out)
assert all_equal(out, true_mg)
def test_fspace_lincomb_vec_tens(a, b, out_shape):
"""Check linear combination in function spaces."""
if out_shape == ():
return
intv = odl.IntervalProd([0, 0], [1, 1])
fspace = FunctionSpace(intv, out_dtype=(float, out_shape))
points = _points(fspace.domain, 4)
ndim = len(out_shape)
if ndim == 1:
f_elem1 = fspace.element(func_vec_nd_oop)
f_elem2 = fspace.element(func_vec_nd_other)
true_result = (a * func_vec_nd_ref(points) +
b * func_vec_nd_other(points))
elif ndim == 2:
f_elem1 = fspace.element(func_tens_oop)
f_elem2 = fspace.element(func_tens_other)
true_result = a * func_tens_ref(points) + b * func_tens_other(points)
else:
assert False
out_func = fspace.element()
fspace.lincomb(a, f_elem1, b, f_elem2, out_func)
assert all_equal(out_func(points), true_result)
out_arr = np.empty(out_shape + (4, ))
out_func(points, out=out_arr)
assert all_equal(out_arr, true_result)
def test_fspace_one(out_shape):
"""Check one element."""
fspace = FunctionSpace(odl.IntervalProd(0, 1),
out_dtype=(float, out_shape))
points = _points(fspace.domain, 4)
mesh_shape = (5, )
mesh = _meshgrid(fspace.domain, mesh_shape)
point = 0.5
values_points_shape = out_shape + (4, )
values_point_shape = out_shape
values_mesh_shape = out_shape + mesh_shape
f_one = fspace.one()
assert all_equal(f_one(points), np.ones(values_points_shape))
if not out_shape:
assert f_one(point) == 1.0
else:
assert all_equal(f_one(point), np.ones(values_point_shape))
assert all_equal(f_one(mesh), np.ones(values_mesh_shape))
out_points = np.empty(values_points_shape)
out_mesh = np.empty(values_mesh_shape)
f_one(points, out=out_points)
f_one(mesh, out=out_mesh)
assert all_equal(out_points, np.ones(values_points_shape))
assert all_equal(out_mesh, np.ones(values_mesh_shape))
def test_nearest_interpolation_1d_complex(fn_impl):
intv = odl.IntervalProd(0, 1)
part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False)
# Coordinate vectors are:
# [0.1, 0.3, 0.5, 0.7, 0.9]
space = odl.FunctionSpace(intv, field=odl.ComplexNumbers())
dspace = odl.cn(part.size)
interp_op = NearestInterpolation(space, part, dspace)
function = interp_op([0 + 1j, 1 + 2j, 2 + 3j, 3 + 4j, 4 + 5j])
# Evaluate at single point
val = function(0.35) # closest to index 1 -> 1 + 2j
assert val == 1.0 + 2.0j
# Input array, with and without output array
pts = np.array([0.4, 0.0, 0.65, 0.95])
true_arr = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j]
assert all_equal(function(pts), true_arr)
# Should also work with a (1, N) array
pts = pts[None, :]
assert all_equal(function(pts), true_arr)
out = np.empty(4, dtype='complex128')
function(pts, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
# Same as array for 1d
mg = sparse_meshgrid([0.4, 0.0, 0.65, 0.95])
true_mg = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j]
assert all_equal(function(mg), true_mg)
function(mg, out=out)
assert all_equal(out, true_mg)
def test_vectorize_callable_class():
# Test vectorization in 1d without data type --> lazy vectorization
arr = [[-2, -1, 0, 1, 2]]
mg = [[-3, -2, -1, 0, 1]]
val_1 = -1
val_2 = 2
# Class with __call__ method
class CallableClass(object):
def __call__(self, x):
return 0 if x < 0 else 1
vectorized_call = vectorize(CallableClass())
true_result_arr = [0, 0, 1, 1, 1]
true_result_mg = [0, 0, 0, 1, 1]
# Out-of-place
out = vectorized_call(arr)
assert isinstance(out, np.ndarray)
assert is_int_dtype(out.dtype)
assert out.shape == (5,)
assert all_equal(out, true_result_arr)
out = vectorized_call(mg)
assert isinstance(out, np.ndarray)
assert out.shape == (5,)
assert is_int_dtype(out.dtype)
assert all_equal(out, true_result_mg)
assert vectorized_call(val_1) == 0
assert vectorized_call(val_2) == 1
def test_gradient_cuda():
"""Discretized spatial gradient operator using CUDA."""
# DiscreteLp Vector
discr_space = odl.uniform_discr([0, 0], [6, 2.5], DATA_2D.shape,
impl='cuda')
dom_vec = discr_space.element(DATA_2D)
# computation of gradient components with helper function
dx0, dx1 = discr_space.cell_sides
diff_0 = finite_diff(DATA_2D, axis=0, dx=dx0, padding_method='constant')
diff_1 = finite_diff(DATA_2D, axis=1, dx=dx1, padding_method='constant')
# gradient
grad = Gradient(discr_space)
grad_vec = grad(dom_vec)
assert len(grad_vec) == DATA_2D.ndim
assert all_equal(grad_vec[0].asarray(), diff_0)
assert all_equal(grad_vec[1].asarray(), diff_1)
# adjoint operator
ran_vec = grad.range.element([DATA_2D, DATA_2D ** 2])
adj_vec = grad.adjoint(ran_vec)
lhs = ran_vec.inner(grad_vec)
rhs = dom_vec.inner(adj_vec)
assert lhs != 0
assert rhs != 0
assert lhs == rhs
def test_vectorize_1d_lazy():
# Test vectorization in 1d without data type --> lazy vectorization
arr = (np.arange(5) - 2)[None, :]
mg = sparse_meshgrid(np.arange(5) - 3)
val_1 = -1
val_2 = 2
@vectorize
def simple_func(x):
return 0 if x < 0 else 1
true_result_arr = [0, 0, 1, 1, 1]
true_result_mg = [0, 0, 0, 1, 1]
# Out-of-place
out = simple_func(arr)
assert isinstance(out, np.ndarray)
assert is_int_dtype(out.dtype)
assert out.shape == (5, )
assert all_equal(out, true_result_arr)
out = simple_func(mg)
assert isinstance(out, np.ndarray)
assert out.shape == (5, )
assert is_int_dtype(out.dtype)
assert all_equal(out, true_result_mg)
assert simple_func(val_1) == 0
assert simple_func(val_2) == 1
def test_element_setitem_fancy():
"""Test assignment of pspace parts with lists."""
pspace = odl.ProductSpace(odl.rn(1), odl.rn(2), odl.rn(3))
x0 = pspace[0].element([0])
x1 = pspace[1].element([1, 2])
x2 = pspace[2].element([3, 4, 5])
x = pspace.element([x0, x1, x2])
old_x0 = x[0]
old_x2 = x[2]
# Check that values are set, but identity is preserved
new_x0 = pspace[0].element([6])
new_x2 = pspace[2].element([7, 8, 9])
x[[0, 2]] = pspace[[0, 2]].element([new_x0, new_x2])
assert x[[0, 2]][0] is old_x0
assert x[[0, 2]][0] == new_x0
assert x[[0, 2]][1] is old_x2
assert x[[0, 2]][1] == new_x2
# Set values with sequences of scalars
x[[0, 2]] = [-1, -2]
assert x[[0, 2]][0] is old_x0
assert all_equal(x[[0, 2]][0], [-1])
assert x[[0, 2]][1] is old_x2
assert all_equal(x[[0, 2]][1], [-2, -2, -2])
def test_uniform_discr_fromdiscr_two_attrs():
# Change 2 attributes -> resize and translate
discr = odl.uniform_discr([0, -1], [1, 1], [10, 5])
# csides = [0.1, 0.4]
new_min_pt = [-2, 1]
new_max_pt = [4, 2]
true_new_csides = [0.6, 0.2]
new_discr = odl.uniform_discr_fromdiscr(discr,
min_pt=new_min_pt,
max_pt=new_max_pt)
assert all_almost_equal(new_discr.min_pt, new_min_pt)
assert all_almost_equal(new_discr.max_pt, new_max_pt)
assert all_equal(new_discr.shape, discr.shape)
assert all_almost_equal(new_discr.cell_sides, true_new_csides)
new_min_pt = [-2, 1]
new_shape = (5, 20)
true_new_max_pt = [-1.5, 9]
new_discr = odl.uniform_discr_fromdiscr(discr,
min_pt=new_min_pt,
shape=new_shape)
assert all_almost_equal(new_discr.min_pt, new_min_pt)
assert all_almost_equal(new_discr.max_pt, true_new_max_pt)
assert all_equal(new_discr.shape, new_shape)
assert all_almost_equal(new_discr.cell_sides, discr.cell_sides)
new_min_pt = [-2, 1]
new_csides = [0.6, 0.2]
true_new_max_pt = [4, 2]
new_discr = odl.uniform_discr_fromdiscr(discr,
min_pt=new_min_pt,
cell_sides=new_csides)
assert all_almost_equal(new_discr.min_pt, new_min_pt)
assert all_almost_equal(new_discr.max_pt, true_new_max_pt)
assert all_equal(new_discr.shape, discr.shape)
assert all_almost_equal(new_discr.cell_sides, new_csides)
new_max_pt = [4, 2]
new_shape = (5, 20)
true_new_min_pt = [3.5, -6]
new_discr = odl.uniform_discr_fromdiscr(discr,
max_pt=new_max_pt,
shape=new_shape)
assert all_almost_equal(new_discr.min_pt, true_new_min_pt)
assert all_almost_equal(new_discr.max_pt, new_max_pt)
assert all_equal(new_discr.shape, new_shape)
assert all_almost_equal(new_discr.cell_sides, discr.cell_sides)
new_max_pt = [4, 2]
new_csides = [0.6, 0.2]
true_new_min_pt = [-2, 1]
new_discr = odl.uniform_discr_fromdiscr(discr,
max_pt=new_max_pt,
cell_sides=new_csides)
assert all_almost_equal(new_discr.min_pt, true_new_min_pt)
assert all_almost_equal(new_discr.max_pt, new_max_pt)
assert all_equal(new_discr.shape, discr.shape)
assert all_almost_equal(new_discr.cell_sides, new_csides)
def test_nearest_interpolation_1d_variants():
intv = odl.Interval(0, 1)
grid = odl.uniform_sampling(intv, 5, as_midp=True)
# Coordinate vectors are:
# [0.1, 0.3, 0.5, 0.7, 0.9]
space = odl.FunctionSpace(intv)
dspace = odl.Rn(grid.ntotal)
# 'left' variant
interp_op = NearestInterpolation(space, grid, dspace, variant='left')
function = interp_op([0, 1, 2, 3, 4])
# Testing two midpoints and the extreme values
pts = np.array([0.4, 0.8, 0.0, 1.0])
true_arr = [1, 3, 0, 4]
assert all_equal(function(pts), true_arr)
# 'right' variant
interp_op = NearestInterpolation(space, grid, dspace, variant='right')
function = interp_op([0, 1, 2, 3, 4])
# Testing two midpoints and the extreme values
pts = np.array([0.4, 0.8, 0.0, 1.0])
true_arr = [2, 4, 0, 4]
assert all_equal(function(pts), true_arr)
def test_vectorize_1d_lazy():
# Test vectorization in 1d without data type --> lazy vectorization
arr = (np.arange(5) - 2)[None, :]
mg = sparse_meshgrid(np.arange(5) - 3)
val_1 = -1
val_2 = 2
@vectorize
def simple_func(x):
return 0 if x < 0 else 1
true_result_arr = [0, 0, 1, 1, 1]
true_result_mg = [0, 0, 0, 1, 1]
# Out-of-place
out = simple_func(arr)
assert isinstance(out, np.ndarray)
assert is_int_dtype(out.dtype)
assert out.shape == (5,)
assert all_equal(out, true_result_arr)
out = simple_func(mg)
assert isinstance(out, np.ndarray)
assert out.shape == (5,)
assert is_int_dtype(out.dtype)
assert all_equal(out, true_result_mg)
assert simple_func(val_1) == 0
assert simple_func(val_2) == 1
def test_vector_numpy():
# Rn
inp = [1.0, 2.0, 3.0]
x = vector(inp)
assert isinstance(x, odl.NumpyFnVector)
assert x.dtype == np.dtype('float64')
assert all_equal(x, inp)
x = vector([1.0, 2.0, float('inf')])
assert x.dtype == np.dtype('float64')
assert isinstance(x, odl.NumpyFnVector)
x = vector([1.0, 2.0, float('nan')])
assert x.dtype == np.dtype('float64')
assert isinstance(x, odl.NumpyFnVector)
x = vector([1, 2, 3], dtype='float32')
assert x.dtype == np.dtype('float32')
assert isinstance(x, odl.NumpyFnVector)
# Cn
inp = [1 + 1j, 2, 3 - 2j]
x = vector(inp)
assert isinstance(x, odl.NumpyFnVector)
assert x.dtype == np.dtype('complex128')
assert all_equal(x, inp)
x = vector([1, 2, 3], dtype='complex64')
assert isinstance(x, odl.NumpyFnVector)
# Fn
inp = [1, 2, 3]
x = vector(inp)
assert isinstance(x, odl.NumpyNtuplesVector)
assert x.dtype == np.dtype('int')
assert all_equal(x, inp)
# Ntuples
inp = ['a', 'b', 'c']
x = vector(inp)
assert isinstance(x, odl.NumpyNtuplesVector)
assert np.issubdtype(x.dtype, basestring)
assert all_equal(x, inp)
x = vector([1, 2, 'inf']) # Becomes string type
assert isinstance(x, odl.NumpyNtuplesVector)
assert np.issubdtype(x.dtype, basestring)
assert all_equal(x, ['1', '2', 'inf'])
# Input not one-dimensional
x = vector(5.0) # OK
assert x.shape == (1,)
with pytest.raises(ValueError):
vector([[1, 0], [0, 1]])
def test_fspace_vector_arithmetic(variant, op):
if variant == 'sv' and '=' in op: # makes no sense, quit
return
# Setup
rect, points, mg = _standard_setup_2d()
point = points.T[0]
fspace = FunctionSpace(rect)
a = -1.5
b = 2.0
array_out = np.empty((5, ), dtype=float)
mg_out = np.empty((2, 3), dtype=float)
# Initialize a bunch of elements
f_novec = fspace.element(func_2d_novec, vectorized=False)
f_vec = fspace.element(func_2d_vec_dual, vectorized=True)
g_novec = fspace.element(other_func_2d_novec, vectorized=False)
g_vec = fspace.element(other_func_2d_vec_dual, vectorized=True)
out_novec = fspace.element(vectorized=False)
out_vec = fspace.element(vectorized=True)
if variant[0] == 'v':
true_l_novec = func_2d_novec(point)
true_l_arr = func_2d_vec_oop(points)
true_l_mg = func_2d_vec_oop(mg)
test_l_novec = f_novec
test_l_vec = f_vec
else: # 's'
true_l_novec = true_l_arr = true_l_mg = a
test_l_novec = test_l_vec = a
if variant[1] == 'v':
true_r_novec = other_func_2d_novec(point)
true_r_arr = other_func_2d_vec_oop(points)
true_r_mg = other_func_2d_vec_oop(mg)
test_r_novec = g_novec
test_r_vec = g_vec
else: # 's'
true_r_novec = true_r_arr = true_r_mg = b
test_r_novec = test_r_vec = b
true_novec = _op(true_l_novec, op, true_r_novec)
true_arr = _op(true_l_arr, op, true_r_arr)
true_mg = _op(true_l_mg, op, true_r_mg)
out_novec = _op(test_l_novec, op, test_r_novec)
out_vec = _op(test_l_vec, op, test_r_vec)
assert almost_equal(out_novec(point), true_novec)
assert all_equal(out_vec(points), true_arr)
out_vec(points, out=array_out)
assert all_equal(array_out, true_arr)
assert all_equal(out_vec(mg), true_mg)
out_vec(mg, out=mg_out)
assert all_equal(mg_out, true_mg)
def test_fspace_vector_arithmetic(variant, op):
if variant == 'sv' and '=' in op: # makes no sense, quit
return
# Setup
rect, points, mg = _standard_setup_2d()
point = points.T[0]
fspace = FunctionSpace(rect)
a = -1.5
b = 2.0
array_out = np.empty((5,), dtype=float)
mg_out = np.empty((2, 3), dtype=float)
# Initialize a bunch of elements
f_novec = fspace.element(func_2d_novec, vectorized=False)
f_vec = fspace.element(func_2d_vec_dual, vectorized=True)
g_novec = fspace.element(other_func_2d_novec, vectorized=False)
g_vec = fspace.element(other_func_2d_vec_dual, vectorized=True)
out_novec = fspace.element(vectorized=False)
out_vec = fspace.element(vectorized=True)
if variant[0] == 'v':
true_l_novec = func_2d_novec(point)
true_l_arr = func_2d_vec_oop(points)
true_l_mg = func_2d_vec_oop(mg)
test_l_novec = f_novec
test_l_vec = f_vec
else: # 's'
true_l_novec = true_l_arr = true_l_mg = a
test_l_novec = test_l_vec = a
if variant[1] == 'v':
true_r_novec = other_func_2d_novec(point)
true_r_arr = other_func_2d_vec_oop(points)
true_r_mg = other_func_2d_vec_oop(mg)
test_r_novec = g_novec
test_r_vec = g_vec
else: # 's'
true_r_novec = true_r_arr = true_r_mg = b
test_r_novec = test_r_vec = b
true_novec = _op(true_l_novec, op, true_r_novec)
true_arr = _op(true_l_arr, op, true_r_arr)
true_mg = _op(true_l_mg, op, true_r_mg)
out_novec = _op(test_l_novec, op, test_r_novec)
out_vec = _op(test_l_vec, op, test_r_vec)
assert almost_equal(out_novec(point), true_novec)
assert all_equal(out_vec(points), true_arr)
out_vec(points, out=array_out)
assert all_equal(array_out, true_arr)
assert all_equal(out_vec(mg), true_mg)
out_vec(mg, out=mg_out)
assert all_equal(mg_out, true_mg)
def test_vector_numpy():
# Rn
inp = [1.0, 2.0, 3.0]
x = vector(inp)
assert isinstance(x, odl.NumpyFnVector)
assert x.dtype == np.dtype('float64')
assert all_equal(x, inp)
x = vector([1.0, 2.0, float('inf')])
assert x.dtype == np.dtype('float64')
assert isinstance(x, odl.NumpyFnVector)
x = vector([1.0, 2.0, float('nan')])
assert x.dtype == np.dtype('float64')
assert isinstance(x, odl.NumpyFnVector)
x = vector([1, 2, 3], dtype='float32')
assert x.dtype == np.dtype('float32')
assert isinstance(x, odl.NumpyFnVector)
# Cn
inp = [1 + 1j, 2, 3 - 2j]
x = vector(inp)
assert isinstance(x, odl.NumpyFnVector)
assert x.dtype == np.dtype('complex128')
assert all_equal(x, inp)
x = vector([1, 2, 3], dtype='complex64')
assert isinstance(x, odl.NumpyFnVector)
# Fn
inp = [1, 2, 3]
x = vector(inp)
assert isinstance(x, odl.NumpyNtuplesVector)
assert x.dtype == np.dtype('int')
assert all_equal(x, inp)
# Ntuples
inp = ['a', 'b', 'c']
x = vector(inp)
assert isinstance(x, odl.NumpyNtuplesVector)
assert np.issubdtype(x.dtype, basestring)
assert all_equal(x, inp)
x = vector([1, 2, 'inf']) # Becomes string type
assert isinstance(x, odl.NumpyNtuplesVector)
assert np.issubdtype(x.dtype, basestring)
assert all_equal(x, ['1', '2', 'inf'])
# Input not one-dimensional
x = vector(5.0) # OK
assert x.shape == (1, )
with pytest.raises(ValueError):
vector([[1, 0], [0, 1]])
def test_parallel_3d_single_axis_geometry():
"""General parallel 3D geometries."""
# Parameters
full_angle = np.pi
apart = odl.uniform_partition(0, full_angle, 10)
dpart = odl.uniform_partition([0, 0], [1, 1], [10, 10])
# Bad init
with pytest.raises(TypeError):
odl.tomo.Parallel3dAxisGeometry([0, 1], dpart)
with pytest.raises(TypeError):
odl.tomo.Parallel3dAxisGeometry(apart, [0, 1])
# Initialize
geom = odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=[0, 0, 1])
with pytest.raises(ValueError):
geom.rotation_matrix(2 * full_angle)
# rotation of cartesian basis vectors about each other
coords = np.eye(3)
geom = odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=[1, 0, 0])
rot_mat = geom.rotation_matrix(np.pi / 2)
assert all_almost_equal(rot_mat.dot(coords),
[[1, 0, 0], [0, 0, -1], [0, 1, 0]])
geom = odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=[0, 1, 0])
rot_mat = geom.rotation_matrix(np.pi / 2)
assert all_almost_equal(rot_mat.dot(coords),
[[0, 0, 1], [0, 1, 0], [-1, 0, 0]])
geom = odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=[0, 0, 1])
rot_mat = geom.rotation_matrix(np.pi / 2)
assert all_almost_equal(rot_mat.dot(coords),
[[0, -1, 0], [1, 0, 0], [0, 0, 1]])
# rotation axis
geom = odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=[1, 0, 0])
assert all_equal(geom.axis, np.array([1, 0, 0]))
geom = odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=[0, 1, 0])
assert all_equal(geom.axis, np.array([0, 1, 0]))
geom = odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=[0, 0, 1])
assert all_equal(geom.axis, np.array([0, 0, 1]))
geom = odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=[1, 2, 3])
assert all_equal(geom.axis,
np.array([1, 2, 3]) / np.linalg.norm([1, 2, 3]))
with pytest.raises(ValueError):
odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=(1, ))
with pytest.raises(ValueError):
odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=(1, 2))
with pytest.raises(ValueError):
odl.tomo.Parallel3dAxisGeometry(apart, dpart, axis=(1, 2, 3, 4))
# check str and repr work without crashing and return something
assert str(geom)
assert repr(geom)
def test_vector_numpy():
# Rn
inp = [[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0]]
x = vector(inp)
assert isinstance(x, NumpyTensor)
assert x.dtype == np.dtype('float64')
assert all_equal(x, inp)
x = vector([1.0, 2.0, float('inf')])
assert x.dtype == np.dtype('float64')
assert isinstance(x, NumpyTensor)
x = vector([1.0, 2.0, float('nan')])
assert x.dtype == np.dtype('float64')
assert isinstance(x, NumpyTensor)
x = vector([1, 2, 3], dtype='float32')
assert x.dtype == np.dtype('float32')
assert isinstance(x, NumpyTensor)
# Cn
inp = [[1 + 1j, 2, 3 - 2j],
[4 + 1j, 5, 6 - 1j]]
x = vector(inp)
assert isinstance(x, NumpyTensor)
assert x.dtype == np.dtype('complex128')
assert all_equal(x, inp)
x = vector([1, 2, 3], dtype='complex64')
assert isinstance(x, NumpyTensor)
# Generic TensorSpace
inp = [1, 2, 3]
x = vector(inp)
assert isinstance(x, NumpyTensor)
assert x.dtype == np.dtype('int')
assert all_equal(x, inp)
inp = ['a', 'b', 'c']
x = vector(inp)
assert isinstance(x, NumpyTensor)
assert np.issubdtype(x.dtype, np.str_)
assert all_equal(x, inp)
x = vector([1, 2, 'inf']) # Becomes string type
assert isinstance(x, NumpyTensor)
assert np.issubdtype(x.dtype, np.str_)
assert all_equal(x, ['1', '2', 'inf'])
# Scalar or empty input
x = vector(5.0) # becomes 1d, size 1
assert x.shape == (1,)
x = vector([]) # becomes 1d, size 0
assert x.shape == (0,)
def test_conj(fn):
xarr, x = noise_elements(fn)
xconj = x.conj()
assert all_equal(xconj, xarr.conj())
y = x.copy()
xconj = x.conj(out=y)
assert xconj is y
assert all_equal(y, xarr.conj())
def test_conj(fn):
xarr, x = _vectors(fn)
xconj = x.conj()
assert all_equal(xconj, xarr.conj())
y = x.copy()
xconj = x.conj(out=y)
assert xconj is y
assert all_equal(y, xarr.conj())
def test_conj(fn):
xarr, x = example_vectors(fn)
xconj = x.conj()
assert all_equal(xconj, xarr.conj())
y = x.copy()
xconj = x.conj(out=y)
assert xconj is y
assert all_equal(y, xarr.conj())
def test_per_axis_interpolation():
"""Test different interpolation schemes per axis."""
rect = odl.IntervalProd([0, 0], [1, 1])
part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False)
# Coordinate vectors are:
# [0.125, 0.375, 0.625, 0.875], [0.25, 0.75]
fspace = odl.FunctionSpace(rect)
tspace = odl.rn(part.shape)
schemes = ['linear', 'nearest']
variants = [None, 'right']
interp_op = PerAxisInterpolation(fspace,
part,
tspace,
schemes=schemes,
nn_variants=variants)
values = np.arange(1, 9, dtype='float64').reshape(part.shape)
function = interp_op(values)
rvals = values.reshape([4, 2])
# Evaluate at single point
val = function([0.3, 0.5])
l1 = (0.3 - 0.125) / (0.375 - 0.125)
# 0.5 equally far from both neighbors -> 'right' chooses 0.75
true_val = (1 - l1) * rvals[0, 1] + l1 * rvals[1, 1]
assert val == pytest.approx(true_val)
# Input array, with and without output array
pts = np.array([[0.3, 0.6], [0.1, 0.25], [1.0, 1.0]])
l1 = (0.3 - 0.125) / (0.375 - 0.125)
true_val_1 = (1 - l1) * rvals[0, 1] + l1 * rvals[1, 1]
l1 = (0.125 - 0.1) / (0.375 - 0.125)
true_val_2 = (1 - l1) * rvals[0, 0] # only lower left contributes
l1 = (1.0 - 0.875) / (0.875 - 0.625)
true_val_3 = (1 - l1) * rvals[3, 1] # lower left only
true_arr = [true_val_1, true_val_2, true_val_3]
assert all_equal(function(pts.T), true_arr)
out = np.empty(3, dtype='float64')
function(pts.T, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
mg = sparse_meshgrid([0.3, 1.0], [0.4, 0.85])
# Indices: (1, 3) x (0, 1)
lx1 = (0.3 - 0.125) / (0.375 - 0.125)
lx2 = (1.0 - 0.875) / (0.875 - 0.625)
true_val_11 = (1 - lx1) * rvals[0, 0] + lx1 * rvals[1, 0]
true_val_12 = ((1 - lx1) * rvals[0, 1] + lx1 * rvals[1, 1])
true_val_21 = (1 - lx2) * rvals[3, 0]
true_val_22 = (1 - lx2) * rvals[3, 1]
true_mg = [[true_val_11, true_val_12], [true_val_21, true_val_22]]
assert all_equal(function(mg), true_mg)
out = np.empty((2, 2), dtype='float64')
function(mg, out=out)
assert all_equal(out, true_mg)
assert repr(interp_op) != ''
def test_discr_part_deriv():
"""Discretized partial derivative."""
discr_space = Rn(1)
with pytest.raises(TypeError):
DiscretePartDeriv(discr_space)
# phantom data
data = np.array([[0., 1., 2., 3., 4.],
[1., 2., 3., 4., 5.],
[2., 3., 4., 5., 6.]])
# explicit calculation of finite difference
# axis: 0
dfe0 = np.zeros_like(data)
# interior: second-order accurate differences
dfe0[1:-1, :] = (data[2:, :] - data[:-2, :]) / 2.0
# boundary: second-order accurate central differences with zero padding
dfe0[0, :] = data[1, :] / 2.0
dfe0[-1, :] = -data[-2, :] / 2.0
# axis: 1
dfe1 = np.zeros_like(data)
# interior: second-order accurate differences
dfe1[:, 1:-1] = (data[:, 2:] - data[:, :-2]) / 2.0
# boundary: second-order accurate central differences with zero padding
dfe1[:, 0] = data[:, 1] / 2.0
dfe1[:, -1] = -data[:, -2] / 2.0
# assert `dfe0` and `dfe1` do differ
assert (dfe0 != dfe1).any()
# discretized space
discr_space = uniform_discr([0, 0], [2, 1], data.shape)
# operator
partial_0 = DiscretePartDeriv(discr_space, axis=0, zero_padding=True)
partial_1 = DiscretePartDeriv(discr_space, axis=1, zero_padding=True)
# discretized space vector
vec = partial_0.domain.element(data)
# partial derivative
partial_vec_0 = partial_0(vec)
partial_vec_1 = partial_1(vec)
assert partial_vec_0 != partial_vec_1
assert all_equal(partial_vec_0.asarray(), dfe0)
assert all_equal(partial_vec_1.asarray(), dfe1)
# operator
partial_0 = DiscretePartDeriv(discr_space, axis=1, dx=0.2, edge_order=2,
zero_padding=True)
# adjoint not implemented
with pytest.raises(NotImplementedError):
partial_0.adjoint
def test_part_deriv_cpu():
"""Discretized partial derivative."""
with pytest.raises(TypeError):
PartialDerivative(odl.Rn(1))
# discretized space
space = odl.uniform_discr([0, 0], [2, 1], DATA_2D.shape)
# operator
partial_0 = PartialDerivative(space, axis=0, method='central',
padding_method='constant')
partial_1 = PartialDerivative(space, axis=1, method='central',
padding_method='constant')
# discretized space vector
vec = partial_0.domain.element(DATA_2D)
# partial derivative
partial_vec_0 = partial_0(vec)
partial_vec_1 = partial_1(vec)
# explicit calculation of finite difference
# axis: 0
diff_0 = np.zeros_like(DATA_2D)
# interior: second-order accurate differences
diff_0[1:-1, :] = (DATA_2D[2:, :] - DATA_2D[:-2, :]) / 2.0
# boundary: second-order accurate central differences with zero padding
diff_0[0, :] = DATA_2D[1, :] / 2.0
diff_0[-1, :] = -DATA_2D[-2, :] / 2.0
diff_0 /= space.cell_sides[0]
# axis: 1
diff_1 = np.zeros_like(DATA_2D)
# interior: second-order accurate differences
diff_1[:, 1:-1] = (DATA_2D[:, 2:] - DATA_2D[:, :-2]) / 2.0
# boundary: second-order accurate central differences with zero padding
diff_1[:, 0] = DATA_2D[:, 1] / 2.0
diff_1[:, -1] = -DATA_2D[:, -2] / 2.0
diff_1 /= space.cell_sides[1]
# assert `dfe0` and `dfe1` do differ
assert (diff_0 != diff_1).any()
assert partial_vec_0 != partial_vec_1
assert all_equal(partial_vec_0.asarray(), diff_0)
assert all_equal(partial_vec_1.asarray(), diff_1)
# adjoint operator
vec1 = space.element(DATA_2D)
vec2 = space.element(DATA_2D + np.random.rand(*DATA_2D.shape))
assert almost_equal(partial_0(vec1).inner(vec2),
vec1.inner(partial_0.adjoint(vec2)))
assert almost_equal(partial_1(vec1).inner(vec2),
vec1.inner(partial_1.adjoint(vec2)))
def test_uniform_discr_fromdiscr_two_attrs():
# Change 2 attributes -> resize and translate
discr = odl.uniform_discr([0, -1], [1, 1], [10, 5])
# csides = [0.1, 0.4]
new_min_pt = [-2, 1]
new_max_pt = [4, 2]
true_new_csides = [0.6, 0.2]
new_discr = odl.uniform_discr_fromdiscr(discr, min_pt=new_min_pt,
max_pt=new_max_pt)
assert all_almost_equal(new_discr.min_pt, new_min_pt)
assert all_almost_equal(new_discr.max_pt, new_max_pt)
assert all_equal(new_discr.shape, discr.shape)
assert all_almost_equal(new_discr.cell_sides, true_new_csides)
new_min_pt = [-2, 1]
new_shape = (5, 20)
true_new_max_pt = [-1.5, 9]
new_discr = odl.uniform_discr_fromdiscr(discr, min_pt=new_min_pt,
shape=new_shape)
assert all_almost_equal(new_discr.min_pt, new_min_pt)
assert all_almost_equal(new_discr.max_pt, true_new_max_pt)
assert all_equal(new_discr.shape, new_shape)
assert all_almost_equal(new_discr.cell_sides, discr.cell_sides)
new_min_pt = [-2, 1]
new_csides = [0.6, 0.2]
true_new_max_pt = [4, 2]
new_discr = odl.uniform_discr_fromdiscr(discr, min_pt=new_min_pt,
cell_sides=new_csides)
assert all_almost_equal(new_discr.min_pt, new_min_pt)
assert all_almost_equal(new_discr.max_pt, true_new_max_pt)
assert all_equal(new_discr.shape, discr.shape)
assert all_almost_equal(new_discr.cell_sides, new_csides)
new_max_pt = [4, 2]
new_shape = (5, 20)
true_new_min_pt = [3.5, -6]
new_discr = odl.uniform_discr_fromdiscr(discr, max_pt=new_max_pt,
shape=new_shape)
assert all_almost_equal(new_discr.min_pt, true_new_min_pt)
assert all_almost_equal(new_discr.max_pt, new_max_pt)
assert all_equal(new_discr.shape, new_shape)
assert all_almost_equal(new_discr.cell_sides, discr.cell_sides)
new_max_pt = [4, 2]
new_csides = [0.6, 0.2]
true_new_min_pt = [-2, 1]
new_discr = odl.uniform_discr_fromdiscr(discr, max_pt=new_max_pt,
cell_sides=new_csides)
assert all_almost_equal(new_discr.min_pt, true_new_min_pt)
assert all_almost_equal(new_discr.max_pt, new_max_pt)
assert all_equal(new_discr.shape, discr.shape)
assert all_almost_equal(new_discr.cell_sides, new_csides)
def test_per_axis_interpolation():
rect = odl.Rectangle([0, 0], [1, 1])
grid = odl.uniform_sampling(rect, [4, 2], as_midp=True)
# Coordinate vectors are:
# [0.125, 0.375, 0.625, 0.875], [0.25, 0.75]
space = odl.FunctionSpace(rect)
dspace = odl.Rn(grid.ntotal)
schemes = ['linear', 'nearest']
variants = [None, 'right']
interp_op = PerAxisInterpolation(space, grid, dspace, schemes=schemes,
nn_variants=variants)
values = np.arange(1, 9, dtype='float64')
function = interp_op(values)
rvals = values.reshape([4, 2])
# Evaluate at single point
val = function([0.3, 0.5])
l1 = (0.3 - 0.125) / (0.375 - 0.125)
# 0.5 equally far from both neighbors -> 'right' chooses 0.75
true_val = (1 - l1) * rvals[0, 1] + l1 * rvals[1, 1]
assert almost_equal(val, true_val)
# Input array, with and without output array
pts = np.array([[0.3, 0.6],
[0.1, 0.25],
[1.0, 1.0]])
l1 = (0.3 - 0.125) / (0.375 - 0.125)
true_val_1 = (1 - l1) * rvals[0, 1] + l1 * rvals[1, 1]
l1 = (0.125 - 0.1) / (0.375 - 0.125)
true_val_2 = (1 - l1) * rvals[0, 0] # only lower left contributes
l1 = (1.0 - 0.875) / (0.875 - 0.625)
true_val_3 = (1 - l1) * rvals[3, 1] # lower left only
true_arr = [true_val_1, true_val_2, true_val_3]
assert all_equal(function(pts.T), true_arr)
out = np.empty(3, dtype='float64')
function(pts.T, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
mg = sparse_meshgrid([0.3, 1.0], [0.4, 0.85])
# Indices: (1, 3) x (0, 1)
lx1 = (0.3 - 0.125) / (0.375 - 0.125)
lx2 = (1.0 - 0.875) / (0.875 - 0.625)
true_val_11 = (1 - lx1) * rvals[0, 0] + lx1 * rvals[1, 0]
true_val_12 = ((1 - lx1) * rvals[0, 1] + lx1 * rvals[1, 1])
true_val_21 = (1 - lx2) * rvals[3, 0]
true_val_22 = (1 - lx2) * rvals[3, 1]
true_mg = [[true_val_11, true_val_12],
[true_val_21, true_val_22]]
assert all_equal(function(mg), true_mg)
out = np.empty((2, 2), dtype='float64')
function(mg, out=out)
assert all_equal(out, true_mg)
def test_linear_interpolation_2d():
"""Test linear interpolation in 2d."""
coord_vecs = [[0.125, 0.375, 0.625, 0.875], [0.25, 0.75]]
f = np.array([[1, 2], [3, 4], [5, 6], [7, 8]], dtype='float64')
interpolator = linear_interpolator(f, coord_vecs)
# Evaluate at single point
val = interpolator([0.3, 0.6])
l1 = (0.3 - 0.125) / (0.375 - 0.125)
l2 = (0.6 - 0.25) / (0.75 - 0.25)
true_val = ((1 - l1) * (1 - l2) * f[0, 0] + (1 - l1) * l2 * f[0, 1] + l1 *
(1 - l2) * f[1, 0] + l1 * l2 * f[1, 1])
assert val == pytest.approx(true_val)
# Input array, with and without output array
pts = np.array([[0.3, 0.6], [0.1, 0.25], [1.0, 1.0]])
l1 = (0.3 - 0.125) / (0.375 - 0.125)
l2 = (0.6 - 0.25) / (0.75 - 0.25)
true_val_1 = ((1 - l1) * (1 - l2) * f[0, 0] + (1 - l1) * l2 * f[0, 1] +
l1 * (1 - l2) * f[1, 0] + l1 * l2 * f[1, 1])
l1 = (0.125 - 0.1) / (0.375 - 0.125)
# l2 = 0
true_val_2 = (1 - l1) * f[0, 0] # only lower left contributes
l1 = (1.0 - 0.875) / (0.875 - 0.625)
l2 = (1.0 - 0.75) / (0.75 - 0.25)
true_val_3 = (1 - l1) * (1 - l2) * f[3, 1] # lower left only
true_arr = [true_val_1, true_val_2, true_val_3]
assert all_equal(interpolator(pts.T), true_arr)
out = np.empty(3, dtype='float64')
interpolator(pts.T, out=out)
assert all_equal(out, true_arr)
# Input meshgrid, with and without output array
mg = sparse_meshgrid([0.3, 1.0], [0.4, 0.75])
# Indices: (1, 3) x (0, 1)
lx1 = (0.3 - 0.125) / (0.375 - 0.125)
lx2 = (1.0 - 0.875) / (0.875 - 0.625)
ly1 = (0.4 - 0.25) / (0.75 - 0.25)
# ly2 = 0
true_val_11 = ((1 - lx1) * (1 - ly1) * f[0, 0] +
(1 - lx1) * ly1 * f[0, 1] + lx1 * (1 - ly1) * f[1, 0] +
lx1 * ly1 * f[1, 1])
true_val_12 = ((1 - lx1) * f[0, 1] + lx1 * f[1, 1] # ly2 = 0
)
true_val_21 = ((1 - lx2) * (1 - ly1) * f[3, 0] +
(1 - lx2) * ly1 * f[3, 1] # high node 1.0, no upper
)
true_val_22 = (1 - lx2) * f[3, 1] # ly2 = 0, no upper for 1.0
true_mg = [[true_val_11, true_val_12], [true_val_21, true_val_22]]
assert all_equal(interpolator(mg), true_mg)
out = np.empty((2, 2), dtype='float64')
interpolator(mg, out=out)
assert all_equal(out, true_mg)
def test_discrete_gradient():
"""Discretized spatial gradient operator."""
discr_space = Rn(1)
with pytest.raises(TypeError):
DiscreteGradient(discr_space)
# Check result of operator with explicit summation
# phantom data
data = np.array([[0., 1., 2., 3., 4.],
[1., 2., 3., 4., 5.],
[2., 3., 4., 5., 6.]])
data = np.array([[0., 1., 2., 3., 4.],
[0., 1., 2., 3., 4.],
[0., 1., 2., 3., 4.]])
# DiscreteLp Vector
discr_space = uniform_discr([0, 0], [6, 2.5], data.shape)
dom_vec = discr_space.element(data)
# computation of gradient components with helper function
dx0, dx1 = discr_space.grid.stride
df0 = finite_diff(data, axis=0, dx=dx0, zero_padding=True, edge_order=2)
df1 = finite_diff(data, axis=1, dx=dx1, zero_padding=True, edge_order=2)
# gradient
grad = DiscreteGradient(discr_space)
grad_vec = grad(dom_vec)
assert len(grad_vec) == data.ndim
assert all_equal(grad_vec[0].asarray(), df0)
assert all_equal(grad_vec[1].asarray(), df1)
# adjoint operator
ran_vec = grad.range.element([data, data ** 2])
adj_vec = grad.adjoint(ran_vec)
lhs = ran_vec.inner(grad_vec)
rhs = dom_vec.inner(adj_vec)
assert lhs != 0
assert rhs != 0
assert lhs == rhs
# higher dimensional arrays
lin_size = 3
for ndim in range(1, 6):
# DiscreteLp Vector
discr_space = uniform_discr([0.] * ndim, [lin_size] * ndim,
[lin_size] * ndim)
dom_vec = discr_space.element(ndvolume(lin_size, ndim))
# gradient
grad = DiscreteGradient(discr_space)
grad(dom_vec)
def test_fspace_vector_ufunc():
intv = odl.IntervalProd(0, 1)
points = _points(intv, num=5)
mg = _meshgrid(intv, shape=(5, ))
fspace = FunctionSpace(intv)
f_vec = fspace.element(np.sin)
assert f_vec(0.5) == np.sin(0.5)
assert all_equal(f_vec(points), np.sin(points.squeeze()))
assert all_equal(f_vec(mg), np.sin(mg[0]))
def test_fspace_vector_ufunc():
intv = odl.Interval(0, 1)
points = _points(intv, num=5)
mg = _meshgrid(intv, shape=(5,))
fspace = FunctionSpace(intv)
f_vec = fspace.element(np.sin)
assert f_vec(0.5) == np.sin(0.5)
assert all_equal(f_vec(points), np.sin(points.squeeze()))
assert all_equal(f_vec(mg), np.sin(mg[0]))
def test_pointwise_sum():
"""PointwiseSum currently depends on PointwiseInner, we verify that."""
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2))
vfspace = ProductSpace(fspace, 3, exponent=2)
# Make sure the code runs and test the properties
psum = PointwiseSum(vfspace)
assert isinstance(psum, PointwiseInner)
assert psum.base_space == fspace
assert all_equal(psum.weights, [1, 1, 1])
assert all_equal(psum.vecfield, psum.domain.one())
def test_getslice():
discr = odl.uniform_discr(0, 1, 3)
vec = discr.element([1, 2, 3])
assert isinstance(vec[:], odl.FnVector)
assert all_equal(vec[:], [1, 2, 3])
discr = odl.uniform_discr(0, 1, 3, field=odl.ComplexNumbers())
vec = discr.element([1 + 2j, 2 - 2j, 3])
assert isinstance(vec[:], odl.FnVector)
assert all_equal(vec[:], [1 + 2j, 2 - 2j, 3])
def test_pointwise_sum():
"""PointwiseSum currently depends on PointwiseInner, we verify that."""
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2))
vfspace = ProductSpace(fspace, 3, exponent=2)
# Make sure the code runs and test the properties
psum = PointwiseSum(vfspace)
assert isinstance(psum, PointwiseInner)
assert psum.base_space == fspace
assert all_equal(psum.weights, [1, 1, 1])
assert all_equal(psum.vecfield, psum.domain.one())
def test_getslice():
discr = odl.uniform_discr(0, 1, 3)
elem = discr.element([1, 2, 3])
assert isinstance(elem[:], odl.NumpyFnVector)
assert all_equal(elem[:], [1, 2, 3])
discr = odl.uniform_discr(0, 1, 3, dtype='complex')
elem = discr.element([1 + 2j, 2 - 2j, 3])
assert isinstance(elem[:], odl.NumpyFnVector)
assert all_equal(elem[:], [1 + 2j, 2 - 2j, 3])
def test_RxR():
H = odl.Rn(2)
HxH = odl.ProductSpace(H, H)
assert len(HxH) == 2
v1 = H.element([1, 2])
v2 = H.element([3, 4])
v = HxH.element([v1, v2])
u = HxH.element([[1, 2], [3, 4]])
assert all_equal([v1, v2], v)
assert all_equal([v1, v2], u)
def test_power_RxR():
H = odl.rn(2)
HxH = odl.ProductSpace(H, 2)
assert len(HxH) == 2
v1 = H.element([1, 2])
v2 = H.element([3, 4])
v = HxH.element([v1, v2])
u = HxH.element([[1, 2], [3, 4]])
assert all_equal([v1, v2], v)
assert all_equal([v1, v2], u)
def test_minpt_maxpt():
vec1 = np.arange(2, 6)
vec2 = np.arange(-4, 5, 2)
vec3 = np.arange(-1, 1)
scalar = 0.5
grid = TensorGrid(vec1, vec2, vec3)
assert all_equal(grid.min_pt, (2, -4, -1))
assert all_equal(grid.max_pt, (5, 4, 0))
grid = TensorGrid(vec1, scalar, vec2, scalar)
assert all_equal(grid.min_pt, (2, 0.5, -4, 0.5))
assert all_equal(grid.max_pt, (5, 0.5, 4, 0.5))
def test_pywt_coeff_list_conversion(small_shapes, floating_dtype):
"""Test if converstion flat array <-> coefficient list works."""
ndim, shapes = small_shapes
grouped_list, flat_list = _grouped_and_flat_arrays(shapes, dtype=float)
true_flat_array = np.hstack(flat_list)
flat_array = pywt_flat_array_from_coeffs(grouped_list)
assert all_equal(flat_array, true_flat_array)
coeff_list = pywt_coeffs_from_flat_array(flat_array, shapes)
true_coeff_list = grouped_list
assert all_equal(coeff_list, true_coeff_list)
