package scipy

  1. Overview
  2. Docs
package scipy
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Interpolate.SmoothSphereBivariateSplineSource

Sourcetype tag = [
  1. | `SmoothSphereBivariateSpline
]
Sourcetype t = [ `Object | `SmoothSphereBivariateSpline ] Obj.t
Sourceval of_pyobject : Py.Object.t -> t
Sourceval to_pyobject : [> tag ] Obj.t -> Py.Object.t
Sourceval create : ?w:[> `Ndarray ] Np.Obj.t -> ?s:float -> ?eps:float -> theta:Py.Object.t -> phi:Py.Object.t -> r:Py.Object.t -> unit -> t

Smooth bivariate spline approximation in spherical coordinates.

.. versionadded:: 0.11.0

Parameters ---------- theta, phi, r : array_like 1-D sequences of data points (order is not important). Coordinates must be given in radians. Theta must lie within the interval (0, pi), and phi must lie within the interval (0, 2pi). w : array_like, optional Positive 1-D sequence of weights. s : float, optional Positive smoothing factor defined for estimation condition: ``sum((w(i)*(r(i) - s(theta(i), phi(i))))**2, axis=0) <= s`` Default ``s=len(w)`` which should be a good value if 1/wi is an estimate of the standard deviation of ri. eps : float, optional A threshold for determining the effective rank of an over-determined linear system of equations. `eps` should have a value between 0 and 1, the default is 1e-16.

Notes ----- For more information, see the FITPACK_ site about this function.

.. _FITPACK: http://www.netlib.org/dierckx/sphere.f

Examples -------- Suppose we have global data on a coarse grid (the input data does not have to be on a grid):

>>> theta = np.linspace(0., np.pi, 7) >>> phi = np.linspace(0., 2*np.pi, 9) >>> data = np.empty((theta.shape0, phi.shape0)) >>> data:,0, data0,:, data-1,: = 0., 0., 0. >>> data1:-1,1, data1:-1,-1 = 1., 1. >>> data1,1:-1, data-2,1:-1 = 1., 1. >>> data2:-2,2, data2:-2,-2 = 2., 2. >>> data2,2:-2, data-3,2:-2 = 2., 2. >>> data3,3:-2 = 3. >>> data = np.roll(data, 4, 1)

We need to set up the interpolator object

>>> lats, lons = np.meshgrid(theta, phi) >>> from scipy.interpolate import SmoothSphereBivariateSpline >>> lut = SmoothSphereBivariateSpline(lats.ravel(), lons.ravel(), ... data.T.ravel(), s=3.5)

As a first test, we'll see what the algorithm returns when run on the input coordinates

>>> data_orig = lut(theta, phi)

Finally we interpolate the data to a finer grid

>>> fine_lats = np.linspace(0., np.pi, 70) >>> fine_lons = np.linspace(0., 2 * np.pi, 90)

>>> data_smth = lut(fine_lats, fine_lons)

>>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax1 = fig.add_subplot(131) >>> ax1.imshow(data, interpolation='nearest') >>> ax2 = fig.add_subplot(132) >>> ax2.imshow(data_orig, interpolation='nearest') >>> ax3 = fig.add_subplot(133) >>> ax3.imshow(data_smth, interpolation='nearest') >>> plt.show()

Sourceval ev : ?dtheta:int -> ?dphi:int -> theta:Py.Object.t -> phi:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Evaluate the spline at points

Returns the interpolated value at ``(thetai, phii), i=0,...,len(theta)-1``.

Parameters ---------- theta, phi : array_like Input coordinates. Standard Numpy broadcasting is obeyed. dtheta : int, optional Order of theta-derivative

.. versionadded:: 0.14.0 dphi : int, optional Order of phi-derivative

.. versionadded:: 0.14.0

Sourceval get_coeffs : [> tag ] Obj.t -> Py.Object.t

Return spline coefficients.

Sourceval get_knots : [> tag ] Obj.t -> Py.Object.t

Return a tuple (tx,ty) where tx,ty contain knots positions of the spline with respect to x-, y-variable, respectively. The position of interior and additional knots are given as tk+1:-k-1 and t:k+1=b, t-k-1:=e, respectively.

Sourceval get_residual : [> tag ] Obj.t -> Py.Object.t

Return weighted sum of squared residuals of the spline approximation: sum ((wi*(zi-s(xi,yi)))**2,axis=0)

Sourceval to_string : t -> string

Print the object to a human-readable representation.

Sourceval show : t -> string

Print the object to a human-readable representation.

Sourceval pp : Format.formatter -> t -> unit

Pretty-print the object to a formatter.