def griddata(points, values, xi, method='linear', fill_value=np.nan, tol = 1e-6):
"""modified griddata plus tol arg"""
points = _ndim_coords_from_arrays(points)
if points.ndim < 2:
ndim = points.ndim
else:
ndim = points.shape[-1]
if ndim == 1 and method in ('nearest', 'linear', 'cubic'):
from interpolate import interp1d
points = points.ravel()
if isinstance(xi, tuple):
if len(xi) != 1:
raise ValueError("invalid number of dimensions in xi")
xi, = xi
# Sort points/values together, necessary as input for interp1d
idx = np.argsort(points)
points = points[idx]
values = values[idx]
ip = interp1d(points, values, kind=method, axis=0, bounds_error=False,
fill_value=fill_value)
return ip(xi)
elif method == 'nearest':
ip = NearestNDInterpolator(points, values)
return ip(xi)
elif method == 'linear':
ip = LinearNDInterpolator(points, values, fill_value=fill_value)
return ip(xi)
elif method == 'cubic' and ndim == 2:
ip = CloughTocher2DInterpolator(points, values, fill_value=fill_value, tol = tol)
return ip(xi)
else:
raise ValueError("Unknown interpolation method %r for "
"%d dimensional data" % (method, ndim))
def __init__(self, name='nport1', nodes=('1', '0', '2', '0'), file="", freq=None):
self.name = name
self.nodes = nodes
self.file = file
self.data = touchstone.snp(self.file).read()
x = []
if freq:
for i in xrange(len(nodes)/2):
row = []
for j in xrange(len(nodes)/2):
freqs = self.data['freq']
sij = self.data['s%d%d'%(i+1,j+1)]
xsij = interp1d(freqs, sij)(freq)
row.append( xsij )
x.append(row)
else:
for i in xrange(len(nodes)/2):
row = []
for j in xrange(len(nodes)/2):
row.append( self.data['s%d%d'%(i+1,j+1)][0] )
freq = self.data['freq'][0]
x.append(row)
self._ivcvs = []
n1 = [newnode() for i in xrange(len(nodes)/2)]
for i in xrange(len(nodes)/2):
self.append( Resistor(name=newname('r'), nodes=(nodes[i*2], n1[i]), r=-50) )
n2 = [newnode() for _i in xrange(len(nodes)/2)] + [nodes[1]]
self.append( Resistor(name=newname('r'), nodes=(n1[i], n2[0]), r=100) )
for j in xrange(len(nodes)/2):
self.append( VCVSx(nodes=(n2[j], n2[j+1], n1[j], nodes[-1]), gain=x[i][j], freq=freq) )
self._ivcvs.append( len(self)-1 )
def test_nd(self):
""" Check the behavior when the inputs and outputs are multidimensional.
"""
# Multidimensional input.
interp10 = interp1d(self.x10, self.y10)
assert_array_almost_equal(
interp10(np.array([[3.4, 5.6], [2.4, 7.8]])),
np.array([[3.4, 5.6], [2.4, 7.8]]),
)
# Multidimensional outputs.
interp210 = interp1d(self.x10, self.y210)
assert_array_almost_equal(
interp210(1.5),
np.array([[1.5], [11.5]]),
)
assert_array_almost_equal(
interp210(np.array([1.5, 2.4])),
np.array([[1.5, 2.4],
[11.5, 12.4]]),
)
interp102 = interp1d(self.x10, self.y102, axis=0)
assert_array_almost_equal(
interp102(1.5),
np.array([[3.0, 4.0]]),
)
assert_array_almost_equal(
interp102(np.array([1.5, 2.4])),
np.array([[3.0, 4.0],
[4.8, 5.8]]),
)
# Both at the same time!
x_new = np.array([[3.4, 5.6], [2.4, 7.8]])
assert_array_almost_equal(
interp210(x_new),
np.array([[[3.4, 5.6], [2.4, 7.8]],
[[13.4, 15.6], [12.4, 17.8]]]),
)
assert_array_almost_equal(
interp102(x_new),
np.array([[[6.8, 7.8], [11.2, 12.2]],
[[4.8, 5.8], [15.6, 16.6]]]),
)
def update_figure(self):
x = np.linspace(0, 10, 10)
y = [random.randint(0, 10) for i in range(10)]
xx = np.linspace(0, 10)
f = interpolate.interp1d(x, y, 'quadratic') # 产生插值曲线的函数
yy = f(xx)
self.axes.cla()
self.axes.plot(x, y, 'o',xx,yy)
self.draw()
def alter(self, freq):
y = []
n = len(self.nodes)/2
freqs = self.data['freq']
for i in xrange(n):
for j in xrange(n):
sij = self.data['s%d%d'%(i+1,j+1)]
xsij = interp1d(freqs, sij)(freq)
y.append( xsij )
netlist = Netlist()
for k, yi in zip(self._ivcvs, y):
netlist.extend( self[k].alter(yi, freq) )
return netlist
def alter(self, freq):
y = []
n = len(self.nodes) / 2
freqs = self.data['freq']
for i in xrange(n):
for j in xrange(n):
sij = self.data['s%d%d' % (i + 1, j + 1)]
xsij = interp1d(freqs, sij)(freq)
y.append(xsij)
netlist = Netlist()
for k, yi in zip(self._ivcvs, y):
netlist.extend(self[k].alter(yi, freq))
return netlist
def test_bounds(self):
""" Test that our handling of out-of-bounds input is correct.
"""
extrap10 = interp1d(self.x10, self.y10, fill_value=self.fill_value,
bounds_error=False)
assert_array_equal(
extrap10(11.2),
np.array([self.fill_value]),
)
assert_array_equal(
extrap10(-3.4),
np.array([self.fill_value]),
)
assert_array_equal(
extrap10._check_bounds(np.array([-1.0, 0.0, 5.0, 9.0, 11.0])),
np.array([True, False, False, False, True]),
)
raises_bounds_error = interp1d(self.x10, self.y10, bounds_error=True)
self.assertRaises(ValueError, raises_bounds_error, -1.0)
self.assertRaises(ValueError, raises_bounds_error, 11.0)
raises_bounds_error([0.0, 5.0, 9.0])
def alter(self, freq):
x = []
for i in xrange(len(self.nodes) / 2):
row = []
for j in xrange(len(self.nodes) / 2):
freqs = self.data['freq']
sij = self.data['s%d%d' % (i + 1, j + 1)]
xsij = interp1d(freqs, sij)(freq)
row.append(xsij)
x.append(row)
y = list(flatten(x))
netlist = Netlist()
for i, k in enumerate(self._ivcvs):
netlist.append(self[k].alter(y[i], freq))
return netlist
def alter(self, freq):
x = []
for i in xrange(len(self.nodes)/2):
row = []
for j in xrange(len(self.nodes)/2):
freqs = self.data['freq']
sij = self.data['s%d%d'%(i+1,j+1)]
xsij = interp1d(freqs, sij)(freq)
row.append( xsij )
x.append(row)
y = list(flatten(x))
netlist = Netlist()
for i, k in enumerate(self._ivcvs):
netlist.append( self[k].alter(y[i], freq) )
return netlist
def test_linear(self):
""" Check the actual implementation of linear interpolation.
"""
interp10 = interp1d(self.x10, self.y10)
assert_array_almost_equal(
interp10(self.x10),
self.y10,
)
assert_array_almost_equal(
interp10(1.2),
np.array([1.2]),
)
assert_array_almost_equal(
interp10([2.4, 5.6, 6.0]),
np.array([2.4, 5.6, 6.0]),
)
def griddata(points, values, xi, method='linear', fill_value=np.nan, tol=1e-6):
"""modified griddata plus tol arg"""
points = _ndim_coords_from_arrays(points)
if points.ndim < 2:
ndim = points.ndim
else:
ndim = points.shape[-1]
if ndim == 1 and method in ('nearest', 'linear', 'cubic'):
from interpolate import interp1d
points = points.ravel()
if isinstance(xi, tuple):
if len(xi) != 1:
raise ValueError("invalid number of dimensions in xi")
xi, = xi
# Sort points/values together, necessary as input for interp1d
idx = np.argsort(points)
points = points[idx]
values = values[idx]
ip = interp1d(points,
values,
kind=method,
axis=0,
bounds_error=False,
fill_value=fill_value)
return ip(xi)
elif method == 'nearest':
ip = NearestNDInterpolator(points, values)
return ip(xi)
elif method == 'linear':
ip = LinearNDInterpolator(points, values, fill_value=fill_value)
return ip(xi)
elif method == 'cubic' and ndim == 2:
ip = CloughTocher2DInterpolator(points,
values,
fill_value=fill_value,
tol=tol)
return ip(xi)
else:
raise ValueError("Unknown interpolation method %r for "
"%d dimensional data" % (method, ndim))
def __init__(self,
name='nport1',
nodes=('1', '0', '2', '0'),
file="",
freq=None):
self.name = name
self.nodes = nodes
self.file = file
self.data = touchstone.snp(self.file).read()
x = []
if freq:
for i in xrange(len(nodes) / 2):
row = []
for j in xrange(len(nodes) / 2):
freqs = self.data['freq']
sij = self.data['s%d%d' % (i + 1, j + 1)]
xsij = interp1d(freqs, sij)(freq)
row.append(xsij)
x.append(row)
else:
for i in xrange(len(nodes) / 2):
row = []
for j in xrange(len(nodes) / 2):
row.append(self.data['s%d%d' % (i + 1, j + 1)][0])
freq = self.data['freq'][0]
x.append(row)
self._ivcvs = []
n1 = [newnode() for i in xrange(len(nodes) / 2)]
for i in xrange(len(nodes) / 2):
self.append(
Resistor(name=newname('r'), nodes=(nodes[i * 2], n1[i]),
r=-50))
n2 = [newnode() for _i in xrange(len(nodes) / 2)] + [nodes[1]]
self.append(
Resistor(name=newname('r'), nodes=(n1[i], n2[0]), r=100))
for j in xrange(len(nodes) / 2):
self.append(
VCVSx(nodes=(n2[j], n2[j + 1], n1[j], nodes[-1]),
gain=x[i][j],
freq=freq))
self._ivcvs.append(len(self) - 1)
def griddata(points, values, xi, method='linear', fill_value=np.nan):
"""
Interpolate unstructured N-dimensional data.
.. versionadded:: 0.9
Parameters
----------
points : ndarray of floats, shape (npoints, ndims)
Data point coordinates. Can either be a ndarray of
size (npoints, ndim), or a tuple of `ndim` arrays.
values : ndarray of float or complex, shape (npoints, ...)
Data values.
xi : ndarray of float, shape (..., ndim)
Points where to interpolate data at.
method : {'linear', 'nearest', 'cubic'}, optional
Method of interpolation. One of
- ``nearest``: return the value at the data point closest to
the point of interpolation. See `NearestNDInterpolator` for
more details.
- ``linear``: tesselate the input point set to n-dimensional
simplices, and interpolate linearly on each simplex. See
`LinearNDInterpolator` for more details.
- ``cubic`` (1-D): return the value detemined from a cubic
spline.
- ``cubic`` (2-D): return the value determined from a
piecewise cubic, continuously differentiable (C1), and
approximately curvature-minimizing polynomial surface. See
`CloughTocher2DInterpolator` for more details.
fill_value : float, optional
Value used to fill in for requested points outside of the
convex hull of the input points. If not provided, then the
default is ``nan``. This option has no effect for the
'nearest' method.
Examples
--------
Suppose we want to interpolate the 2-D function
>>> def func(x, y):
>>> return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2
on a grid in [0, 1]x[0, 1]
>>> grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]
but we only know its values at 1000 data points:
>>> points = np.random.rand(1000, 2)
>>> values = func(points[:,0], points[:,1])
This can be done with `griddata` -- below we try out all of the
interpolation methods:
>>> from scipy.interpolate import griddata
>>> grid_z0 = griddata(points, values, (grid_x, grid_y), method='nearest')
>>> grid_z1 = griddata(points, values, (grid_x, grid_y), method='linear')
>>> grid_z2 = griddata(points, values, (grid_x, grid_y), method='cubic')
One can see that the exact result is reproduced by all of the
methods to some degree, but for this smooth function the piecewise
cubic interpolant gives the best results:
>>> import matplotlib.pyplot as plt
>>> plt.subplot(221)
>>> plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin='lower')
>>> plt.plot(points[:,0], points[:,1], 'k.', ms=1)
>>> plt.title('Original')
>>> plt.subplot(222)
>>> plt.imshow(grid_z0.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Nearest')
>>> plt.subplot(223)
>>> plt.imshow(grid_z1.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Linear')
>>> plt.subplot(224)
>>> plt.imshow(grid_z2.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Cubic')
>>> plt.gcf().set_size_inches(6, 6)
>>> plt.show()
"""
points = _ndim_coords_from_arrays(points)
if points.ndim < 2:
ndim = points.ndim
else:
ndim = points.shape[-1]
if ndim == 1 and method in ('nearest', 'linear', 'cubic'):
from interpolate import interp1d
points = points.ravel()
if isinstance(xi, tuple):
if len(xi) != 1:
raise ValueError("invalid number of dimensions in xi")
xi, = xi
# Sort points/values together, necessary as input for interp1d
idx = np.argsort(points)
points = points[idx]
values = values[idx]
ip = interp1d(points,
values,
kind=method,
axis=0,
bounds_error=False,
fill_value=fill_value)
return ip(xi)
elif method == 'nearest':
ip = NearestNDInterpolator(points, values)
return ip(xi)
elif method == 'linear':
ip = LinearNDInterpolator(points, values, fill_value=fill_value)
return ip(xi)
elif method == 'cubic' and ndim == 2:
ip = CloughTocher2DInterpolator(points, values, fill_value=fill_value)
return ip(xi)
else:
raise ValueError("Unknown interpolation method %r for "
"%d dimensional data" % (method, ndim))
def griddata(points, values, xi, method='linear', fill_value=np.nan):
"""
Interpolate unstructured N-dimensional data.
.. versionadded:: 0.9
Parameters
----------
points : ndarray of floats, shape (npoints, ndims)
Data point coordinates. Can either be a ndarray of
size (npoints, ndim), or a tuple of `ndim` arrays.
values : ndarray of float or complex, shape (npoints, ...)
Data values.
xi : ndarray of float, shape (..., ndim)
Points where to interpolate data at.
method : {'linear', 'nearest', 'cubic'}, optional
Method of interpolation. One of
- ``nearest``: return the value at the data point closest to
the point of interpolation. See `NearestNDInterpolator` for
more details.
- ``linear``: tesselate the input point set to n-dimensional
simplices, and interpolate linearly on each simplex. See
`LinearNDInterpolator` for more details.
- ``cubic`` (1-D): return the value determined from a cubic
spline.
- ``cubic`` (2-D): return the value determined from a
piecewise cubic, continuously differentiable (C1), and
approximately curvature-minimizing polynomial surface. See
`CloughTocher2DInterpolator` for more details.
fill_value : float, optional
Value used to fill in for requested points outside of the
convex hull of the input points. If not provided, then the
default is ``nan``. This option has no effect for the
'nearest' method.
Examples
--------
Suppose we want to interpolate the 2-D function
>>> def func(x, y):
>>> return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2
on a grid in [0, 1]x[0, 1]
>>> grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]
but we only know its values at 1000 data points:
>>> points = np.random.rand(1000, 2)
>>> values = func(points[:,0], points[:,1])
This can be done with `griddata` -- below we try out all of the
interpolation methods:
>>> from scipy.interpolate import griddata
>>> grid_z0 = griddata(points, values, (grid_x, grid_y), method='nearest')
>>> grid_z1 = griddata(points, values, (grid_x, grid_y), method='linear')
>>> grid_z2 = griddata(points, values, (grid_x, grid_y), method='cubic')
One can see that the exact result is reproduced by all of the
methods to some degree, but for this smooth function the piecewise
cubic interpolant gives the best results:
>>> import matplotlib.pyplot as plt
>>> plt.subplot(221)
>>> plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin='lower')
>>> plt.plot(points[:,0], points[:,1], 'k.', ms=1)
>>> plt.title('Original')
>>> plt.subplot(222)
>>> plt.imshow(grid_z0.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Nearest')
>>> plt.subplot(223)
>>> plt.imshow(grid_z1.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Linear')
>>> plt.subplot(224)
>>> plt.imshow(grid_z2.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Cubic')
>>> plt.gcf().set_size_inches(6, 6)
>>> plt.show()
"""
points = _ndim_coords_from_arrays(points)
if points.ndim < 2:
ndim = points.ndim
else:
ndim = points.shape[-1]
if ndim == 1 and method in ('nearest', 'linear', 'cubic'):
from interpolate import interp1d
points = points.ravel()
if isinstance(xi, tuple):
if len(xi) != 1:
raise ValueError("invalid number of dimensions in xi")
xi, = xi
# Sort points/values together, necessary as input for interp1d
idx = np.argsort(points)
points = points[idx]
values = values[idx]
ip = interp1d(points, values, kind=method, axis=0, bounds_error=False,
fill_value=fill_value)
return ip(xi)
elif method == 'nearest':
ip = NearestNDInterpolator(points, values)
return ip(xi)
elif method == 'linear':
ip = LinearNDInterpolator(points, values, fill_value=fill_value)
return ip(xi)
elif method == 'cubic' and ndim == 2:
ip = CloughTocher2DInterpolator(points, values, fill_value=fill_value)
return ip(xi)
else:
raise ValueError("Unknown interpolation method %r for "
"%d dimensional data" % (method, ndim))
def test_validation(self):
""" Make sure that appropriate exceptions are raised when invalid values
are given to the constructor.
"""
# These should all work.
interp1d(self.x10, self.y10, kind='linear')
interp1d(self.x10, self.y10, kind='cubic')
interp1d(self.x10, self.y10, kind='slinear')
interp1d(self.x10, self.y10, kind='quadratic')
interp1d(self.x10, self.y10, kind='zero')
interp1d(self.x10, self.y10, kind=0)
interp1d(self.x10, self.y10, kind=1)
interp1d(self.x10, self.y10, kind=2)
interp1d(self.x10, self.y10, kind=3)
# x array must be 1D.
self.assertRaises(ValueError, interp1d, self.x25, self.y10)
# y array cannot be a scalar.
self.assertRaises(ValueError, interp1d, self.x10, np.array(0))
# Check for x and y arrays having the same length.
self.assertRaises(ValueError, interp1d, self.x10, self.y2)
self.assertRaises(ValueError, interp1d, self.x2, self.y10)
self.assertRaises(ValueError, interp1d, self.x10, self.y102)
interp1d(self.x10, self.y210)
interp1d(self.x10, self.y102, axis=0)
# Check for x and y having at least 1 element.
self.assertRaises(ValueError, interp1d, self.x1, self.y10)
self.assertRaises(ValueError, interp1d, self.x10, self.y1)
self.assertRaises(ValueError, interp1d, self.x1, self.y1)
tanData = op('tangents').rows()
resolution = op('res')[0]
points = [[float(x[0].val), float(x[1].val)] for x in posData]
tangents = [[float(x[0].val), float(x[1].val)] for x in tanData]
points = np.asarray(points)
tangents = np.asarray(tangents)
# Interpolate with different tangent lengths, but equal direction.
tangents = np.dot(tangents, np.eye(2))
samples = curve.sampleCubicSplinesWithDerivative(points, tangents, resolution)
# equispaced x
x = samples[:, 0]
y = samples[:, 1]
f = interpolate.interp1d(x, y)
x_new = np.linspace(np.min(x), np.max(x), x.shape[0])
y_new = f(x_new)
table = op('equispaced_x')
table.clear(keepFirstRow=True)
table.appendRows(y_new)
# original
"""
table = op('original')
table.clear(keepFirstRow = True)
table.appendRows(samples)
"""
# equispaced x and y
for ntest in range(ntests):
# draw the data
x = torch.rand(D, N, device='cuda') * 10000
x = x.sort(dim=1)[0]
y = torch.linspace(0, 1000, D * N).to('cuda').view(D, -1)
y -= y[:, 0, None]
xnew = torch.rand(Dnew, P, device='cuda') * 10000
print('Solving %d interpolation problems: '
'each with %d observations and %d desired values' % (D, N, P))
# launching the cuda version
t0 = time.time()
yq_gpu = interp1d(x, y, xnew, yq_gpu, cuda=True)
t1 = time.time()
# putting everything back to CPU before calling the CPU version
x = x.to('cpu')
y = y.to('cpu')
xnew = xnew.to('cpu')
# calling the cpu version
t0_cpu = time.time()
yq_cpu = interp1d(x, y, xnew, yq_cpu, cuda=False)
t1_cpu = time.time()
# compute the difference between both
error = torch.norm(yq_cpu -
yq_gpu.to('cpu')) / torch.norm(yq_cpu) * 100.
def test_init(self):
""" Check that the attributes are initialized appropriately by the
constructor.
"""
self.assert_(interp1d(self.x10, self.y10).copy)
self.assert_(not interp1d(self.x10, self.y10, copy=False).copy)
self.assert_(interp1d(self.x10, self.y10).bounds_error)
self.assert_(not interp1d(self.x10, self.y10, bounds_error=False).bounds_error)
self.assert_(np.isnan(interp1d(self.x10, self.y10).fill_value))
self.assertEqual(
interp1d(self.x10, self.y10, fill_value=3.0).fill_value,
3.0,
)
self.assertEqual(
interp1d(self.x10, self.y10).axis,
0,
)
self.assertEqual(
interp1d(self.x10, self.y210).axis,
1,
)
self.assertEqual(
interp1d(self.x10, self.y102, axis=0).axis,
0,
)
assert_array_equal(
interp1d(self.x10, self.y10).x,
self.x10,
)
assert_array_equal(
interp1d(self.x10, self.y10).y,
self.y10,
)
assert_array_equal(
interp1d(self.x10, self.y210).y,
self.y210,
)
