def test_init(exponent):
# Validate that the different init patterns work and do not crash.
space = odl.FunctionSpace(odl.IntervalProd(0, 1))
part = odl.uniform_partition_fromintv(space.domain, 10)
rn = odl.rn(10, exponent=exponent)
odl.DiscreteLp(space, part, rn, exponent=exponent)
odl.DiscreteLp(space, part, rn, exponent=exponent, interp='linear')
# Normal discretization of unit interval with complex
complex_space = odl.FunctionSpace(odl.IntervalProd(0, 1),
field=odl.ComplexNumbers())
cn = odl.cn(10, exponent=exponent)
odl.DiscreteLp(complex_space, part, cn, exponent=exponent)
space = odl.FunctionSpace(odl.IntervalProd([0, 0], [1, 1]))
part = odl.uniform_partition_fromintv(space.domain, (10, 10))
rn = odl.rn(100, exponent=exponent)
odl.DiscreteLp(space, part, rn, exponent=exponent,
interp=['nearest', 'linear'])
# Real space should not work with complex
with pytest.raises(ValueError):
odl.DiscreteLp(space, part, cn)
# Complex space should not work with reals
with pytest.raises(ValueError):
odl.DiscreteLp(complex_space, part, rn)
# Wrong size of underlying space
rn_wrong_size = odl.rn(20)
with pytest.raises(ValueError):
odl.DiscreteLp(space, part, rn_wrong_size)
def test_init(exponent):
# Validate that the different init patterns work and do not crash.
space = odl.FunctionSpace(odl.IntervalProd(0, 1))
part = odl.uniform_partition_fromintv(space.domain, 10)
rn = odl.rn(10, exponent=exponent)
odl.DiscreteLp(space, part, rn, exponent=exponent)
odl.DiscreteLp(space, part, rn, exponent=exponent, interp='linear')
# Normal discretization of unit interval with complex
complex_space = odl.FunctionSpace(odl.IntervalProd(0, 1),
field=odl.ComplexNumbers())
cn = odl.cn(10, exponent=exponent)
odl.DiscreteLp(complex_space, part, cn, exponent=exponent)
space = odl.FunctionSpace(odl.IntervalProd([0, 0], [1, 1]))
part = odl.uniform_partition_fromintv(space.domain, (10, 10))
rn = odl.rn(100, exponent=exponent)
odl.DiscreteLp(space, part, rn, exponent=exponent,
interp=['nearest', 'linear'])
# Real space should not work with complex
with pytest.raises(ValueError):
odl.DiscreteLp(space, part, cn)
# Complex space should not work with reals
with pytest.raises(ValueError):
odl.DiscreteLp(complex_space, part, rn)
# Wrong size of underlying space
rn_wrong_size = odl.rn(20)
with pytest.raises(ValueError):
odl.DiscreteLp(space, part, rn_wrong_size)
def test_discretelp_init():
"""Test initialization and basic properties of DiscreteLp."""
# Real space
fspace = odl.FunctionSpace(odl.IntervalProd([0, 0], [1, 1]))
part = odl.uniform_partition_fromintv(fspace.domain, (2, 4))
tspace = odl.rn(part.shape)
discr = DiscreteLp(fspace, part, tspace)
assert discr.fspace == fspace
assert discr.tspace == tspace
assert discr.partition == part
assert discr.interp == 'nearest'
assert discr.interp_byaxis == ('nearest', 'nearest')
assert discr.exponent == tspace.exponent
assert discr.axis_labels == ('$x$', '$y$')
assert discr.is_real
discr = DiscreteLp(fspace, part, tspace, interp='linear')
assert discr.interp == 'linear'
assert discr.interp_byaxis == ('linear', 'linear')
discr = DiscreteLp(fspace, part, tspace, interp=['nearest', 'linear'])
assert discr.interp == ('nearest', 'linear')
assert discr.interp_byaxis == ('nearest', 'linear')
# Complex space
fspace_c = odl.FunctionSpace(odl.IntervalProd([0, 0], [1, 1]),
out_dtype=complex)
tspace_c = odl.cn(part.shape)
discr = DiscreteLp(fspace_c, part, tspace_c)
assert discr.is_complex
# Make sure repr shows something
assert repr(discr)
# Error scenarios
with pytest.raises(ValueError):
DiscreteLp(fspace, part, tspace_c) # mixes real & complex
with pytest.raises(ValueError):
DiscreteLp(fspace_c, part, tspace) # mixes complex & real
part_1d = odl.uniform_partition(0, 1, 2)
with pytest.raises(ValueError):
DiscreteLp(fspace, part_1d, tspace) # wrong dimensionality
part_diffshp = odl.uniform_partition_fromintv(fspace.domain, (3, 4))
with pytest.raises(ValueError):
DiscreteLp(fspace, part_diffshp, tspace) # shape mismatch
def test_uniform_partition_fromintv():
intvp = odl.IntervalProd([0, 0], [1, 2])
shape = (4, 10)
# All nodes at the boundary
part = odl.uniform_partition_fromintv(intvp, shape, nodes_on_bdry=True)
assert all_equal(part.min_pt, intvp.min_pt)
assert all_equal(part.max_pt, intvp.max_pt)
assert all_equal(part.grid.min_pt, intvp.min_pt)
assert all_equal(part.grid.max_pt, intvp.max_pt)
for cs in part.cell_sizes_vecs:
# Check that all cell sizes are equal (except first and last which
# are halved)
assert np.allclose(np.diff(cs[1:-1]), 0)
assert all_almost_equal(cs[0], cs[1] / 2)
assert all_almost_equal(cs[-1], cs[-2] / 2)
# All nodes not the boundary
part = odl.uniform_partition_fromintv(intvp, shape, nodes_on_bdry=False)
assert all_equal(part.min_pt, intvp.min_pt)
assert all_equal(part.max_pt, intvp.max_pt)
for cs in part.cell_sizes_vecs:
# Check that all cell sizes are equal
assert np.allclose(np.diff(cs), 0)
# Only left nodes at the boundary
part = odl.uniform_partition_fromintv(intvp,
shape,
nodes_on_bdry=[[True, False]] * 2)
assert all_equal(part.min_pt, intvp.min_pt)
assert all_equal(part.max_pt, intvp.max_pt)
assert all_equal(part.grid.min_pt, intvp.min_pt)
for cs in part.cell_sizes_vecs:
# Check that all cell sizes are equal (except first)
assert np.allclose(np.diff(cs[1:]), 0)
assert all_almost_equal(cs[0], cs[1] / 2)
# Only right nodes at the boundary
part = odl.uniform_partition_fromintv(intvp,
shape,
nodes_on_bdry=[[False, True]] * 2)
assert all_equal(part.min_pt, intvp.min_pt)
assert all_equal(part.max_pt, intvp.max_pt)
assert all_equal(part.grid.max_pt, intvp.max_pt)
for cs in part.cell_sizes_vecs:
# Check that all cell sizes are equal (except last)
assert np.allclose(np.diff(cs[:-1]), 0)
assert all_almost_equal(cs[-1], cs[-2] / 2)
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_nearest_interpolation_2d_string():
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]
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_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(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_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_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_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_collocation_interpolation_identity():
"""Check if collocation is left-inverse to interpolation."""
# Interpolation followed by collocation on the same grid should be
# the identity
rect = odl.IntervalProd([0, 0], [1, 1])
part = odl.uniform_partition_fromintv(rect, [4, 2])
space = odl.FunctionSpace(rect)
tspace = odl.rn(part.shape)
coll_op = PointCollocation(space, part, tspace)
interp_ops = [
NearestInterpolation(space, part, tspace, variant='left'),
NearestInterpolation(space, part, tspace, variant='right'),
LinearInterpolation(space, part, tspace),
PerAxisInterpolation(space,
part,
tspace,
schemes=['linear', 'nearest'])
]
values = np.arange(1, 9, dtype='float64').reshape(tspace.shape)
for interp_op in interp_ops:
ident_values = coll_op(interp_op(values))
assert all_almost_equal(ident_values, values)
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_nearest_interpolation_2d_float():
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]
space = odl.FunctionSpace(rect)
dspace = odl.rn(part.size)
interp_op = NearestInterpolation(space, part, 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_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_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_collocation_interpolation_identity():
# Check if interpolation followed by collocation on the same grid
# is the identity
rect = odl.IntervalProd([0, 0], [1, 1])
part = odl.uniform_partition_fromintv(rect, [4, 2])
space = odl.FunctionSpace(rect)
dspace = odl.rn(part.size)
coll_op_c = PointCollocation(space, part, dspace, order='C')
coll_op_f = PointCollocation(space, part, dspace, order='F')
interp_ops_c = [
NearestInterpolation(space, part, dspace, variant='left', order='C'),
NearestInterpolation(space, part, dspace, variant='right', order='C'),
LinearInterpolation(space, part, dspace, order='C'),
PerAxisInterpolation(space, part, dspace, order='C',
schemes=['linear', 'nearest'])]
interp_ops_f = [
NearestInterpolation(space, part, dspace, variant='left', order='F'),
NearestInterpolation(space, part, dspace, variant='right', order='F'),
LinearInterpolation(space, part, dspace, order='F'),
PerAxisInterpolation(space, part, dspace, order='F',
schemes=['linear', 'nearest'])]
values = np.arange(1, 9, dtype='float64')
for interp_op_c in interp_ops_c:
ident_values = coll_op_c(interp_op_c(values))
assert all_almost_equal(ident_values, values)
for interp_op_f in interp_ops_f:
ident_values = coll_op_f(interp_op_f(values))
assert all_almost_equal(ident_values, values)
def test_uniform_partition_fromintv():
intvp = odl.IntervalProd([0, 0], [1, 2])
nsamp = (4, 10)
# All nodes at the boundary
part = odl.uniform_partition_fromintv(intvp, nsamp, nodes_on_bdry=True)
assert all_equal(part.begin, intvp.begin)
assert all_equal(part.end, intvp.end)
assert all_equal(part.grid.min_pt, intvp.begin)
assert all_equal(part.grid.max_pt, intvp.end)
for cs in part.cell_sizes_vecs:
# Check that all cell sizes are equal (except first and last which
# are halved)
assert np.allclose(np.diff(cs[1:-1]), 0)
assert all_almost_equal(cs[0], cs[1] / 2)
assert all_almost_equal(cs[-1], cs[-2] / 2)
# All nodes not the boundary
part = odl.uniform_partition_fromintv(intvp, nsamp, nodes_on_bdry=False)
assert all_equal(part.begin, intvp.begin)
assert all_equal(part.end, intvp.end)
for cs in part.cell_sizes_vecs:
# Check that all cell sizes are equal
assert np.allclose(np.diff(cs), 0)
# Only left nodes at the boundary
part = odl.uniform_partition_fromintv(intvp, nsamp,
nodes_on_bdry=[[True, False]] * 2)
assert all_equal(part.begin, intvp.begin)
assert all_equal(part.end, intvp.end)
assert all_equal(part.grid.min_pt, intvp.begin)
for cs in part.cell_sizes_vecs:
# Check that all cell sizes are equal (except first)
assert np.allclose(np.diff(cs[1:]), 0)
assert all_almost_equal(cs[0], cs[1] / 2)
# Only right nodes at the boundary
part = odl.uniform_partition_fromintv(intvp, nsamp,
nodes_on_bdry=[[False, True]] * 2)
assert all_equal(part.begin, intvp.begin)
assert all_equal(part.end, intvp.end)
assert all_equal(part.grid.max_pt, intvp.end)
for cs in part.cell_sizes_vecs:
# Check that all cell sizes are equal (except last)
assert np.allclose(np.diff(cs[:-1]), 0)
assert all_almost_equal(cs[-1], cs[-2] / 2)
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_per_axis_interpolation():
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]
space = odl.FunctionSpace(rect)
dspace = odl.rn(part.size)
schemes = ['linear', 'nearest']
variants = [None, 'right']
interp_op = PerAxisInterpolation(space, part, 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_collocation_cuda():
rect = odl.Rectangle([0, 0], [1, 1])
part = odl.uniform_partition_fromintv(rect, [4, 2])
space = odl.FunctionSpace(rect)
dspace = odl.CudaRn(part.size)
coll_op = PointCollocation(space, part, dspace)
interp_op = LinearInterpolation(space, part, dspace)
values = np.arange(1, 9, dtype='float64')
ident_values = coll_op(interp_op(values))
assert all_almost_equal(ident_values, values)
def test_collocation_cuda():
rect = odl.Rectangle([0, 0], [1, 1])
part = odl.uniform_partition_fromintv(rect, [4, 2])
space = odl.FunctionSpace(rect)
dspace = odl.CudaRn(part.size)
coll_op = PointCollocation(space, part, dspace)
interp_op = LinearInterpolation(space, part, dspace)
values = np.arange(1, 9, dtype='float64')
ident_values = coll_op(interp_op(values))
assert all_almost_equal(ident_values, values)
def test_linear_interpolation_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]
space = odl.FunctionSpace(intv)
dspace = odl.rn(part.size)
interp_op = LinearInterpolation(space, part, dspace)
function = interp_op([1, 2, 3, 4, 5])
# Evaluate at single point
val = function(0.35)
true_val = 0.75 * 2 + 0.25 * 3
assert almost_equal(val, true_val)
# Input array, with and without output array
pts = np.array([0.4, 0.0, 0.65, 0.95])
true_arr = [2.5, 0.5, 3.75, 3.75]
assert all_almost_equal(function(pts), true_arr)
def test_linear_interpolation_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]
space = odl.FunctionSpace(intv)
dspace = odl.rn(part.size)
interp_op = LinearInterpolation(space, part, dspace)
function = interp_op([1, 2, 3, 4, 5])
# Evaluate at single point
val = function(0.35)
true_val = 0.75 * 2 + 0.25 * 3
assert almost_equal(val, true_val)
# Input array, with and without output array
pts = np.array([0.4, 0.0, 0.65, 0.95])
true_arr = [2.5, 0.5, 3.75, 3.75]
assert all_almost_equal(function(pts), true_arr)
def test_init_cuda(exponent):
# Normal discretization of unit interval
space = odl.FunctionSpace(odl.Interval(0, 1), out_dtype='float32')
part = odl.uniform_partition_fromintv(space.domain, 10)
rn = odl.CudaRn(10, exponent=exponent)
odl.DiscreteLp(space, part, rn, exponent=exponent)
def test_init_cuda(exponent):
# Normal discretization of unit interval
space = odl.FunctionSpace(odl.Interval(0, 1), out_dtype='float32')
part = odl.uniform_partition_fromintv(space.domain, 10)
rn = odl.CudaRn(10, exponent=exponent)
odl.DiscreteLp(space, part, rn, exponent=exponent)
def test_linear_interpolation_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]
space = odl.FunctionSpace(rect)
dspace = odl.rn(part.size)
interp_op = LinearInterpolation(space, part, dspace)
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.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) * rvals[0, 0] +
(1 - l1) * l2 * rvals[0, 1] +
l1 * (1 - l2) * rvals[1, 0] +
l1 * l2 * 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)
l2 = (0.6 - 0.25) / (0.75 - 0.25)
true_val_1 = ((1 - l1) * (1 - l2) * rvals[0, 0] +
(1 - l1) * l2 * rvals[0, 1] +
l1 * (1 - l2) * rvals[1, 0] +
l1 * l2 * rvals[1, 1])
l1 = (0.125 - 0.1) / (0.375 - 0.125)
# l2 = 0
true_val_2 = (1 - l1) * rvals[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) * 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.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) * rvals[0, 0] +
(1 - lx1) * ly1 * rvals[0, 1] +
lx1 * (1 - ly1) * rvals[1, 0] +
lx1 * ly1 * rvals[1, 1])
true_val_12 = ((1 - lx1) * rvals[0, 1] + lx1 * rvals[1, 1]) # ly2 = 0
true_val_21 = ((1 - lx2) * (1 - ly1) * rvals[3, 0] +
(1 - lx2) * ly1 * rvals[3, 1]) # high node 1.0, no upper
true_val_22 = (1 - lx2) * rvals[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(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."""
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 = LinearInterpolation(fspace, part, tspace)
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.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) * rvals[0, 0] +
(1 - l1) * l2 * rvals[0, 1] + l1 * (1 - l2) * rvals[1, 0] +
l1 * l2 * 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)
l2 = (0.6 - 0.25) / (0.75 - 0.25)
true_val_1 = ((1 - l1) * (1 - l2) * rvals[0, 0] +
(1 - l1) * l2 * rvals[0, 1] + l1 * (1 - l2) * rvals[1, 0] +
l1 * l2 * rvals[1, 1])
l1 = (0.125 - 0.1) / (0.375 - 0.125)
# l2 = 0
true_val_2 = (1 - l1) * rvals[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) * 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.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) * rvals[0, 0] +
(1 - lx1) * ly1 * rvals[0, 1] + lx1 *
(1 - ly1) * rvals[1, 0] + lx1 * ly1 * rvals[1, 1])
true_val_12 = ((1 - lx1) * rvals[0, 1] + lx1 * rvals[1, 1]) # ly2 = 0
true_val_21 = (
(1 - lx2) * (1 - ly1) * rvals[3, 0] + (1 - lx2) * ly1 * rvals[3, 1]
) # high node 1.0, no upper
true_val_22 = (1 - lx2) * rvals[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(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) != ''
