#### Previous topic

scipy.interpolate.CloughTocher2DInterpolator.__call__

#### Next topic

scipy.interpolate.Rbf.__call__

# scipy.interpolate.Rbf

class `scipy.interpolate.``Rbf`(*args)

  A class for radial basis function approximation/interpolation of n-dimensional scattered data.

  Parameters:

  *args : arrays

  > x, y, z, ..., d, where x, y, z, ... are the coordinates of the nodes and d is the array of values at the nodes

  function : str or callable, optional

  > The radial basis function, based on the radius, r, given by the norm (default is Euclidean distance); the default is ‘multiquadric’:

  >     'multiquadric': sqrt((r/self.epsilon)**2 + 1)
  >     'inverse': 1.0/sqrt((r/self.epsilon)**2 + 1)
  >     'gaussian': exp(-(r/self.epsilon)**2)
  >     'linear': r
  >     'cubic': r**3
  >     'quintic': r**5
  >     'thin_plate': r**2 * log(r)

  > If callable, then it must take 2 arguments (self, r). The epsilon parameter will be available as self.epsilon. Other keyword arguments passed in will be available as well.

  epsilon : float, optional

  > Adjustable constant for gaussian or multiquadrics functions - defaults to approximate average distance between nodes (which is a good start).

  smooth : float, optional

  > Values greater than zero increase the smoothness of the approximation. 0 is for interpolation (default), the function will always go through the nodal points in this case.

  norm : callable, optional

  > A function that returns the ‘distance’ between two points, with inputs as arrays of positions (x, y, z, ...), and an output as an array of distance. E.g, the default:

  >     def euclidean_norm(x1, x2):
  >         return sqrt( ((x1 - x2)**2).sum(axis=0) )

  > which is called with x1=x1[ndims,newaxis,:] and x2=x2[ndims,:,newaxis] such that the result is a matrix of the distances from each point in x1 to each point in x2.

  Examples

      >>> from scipy.interpolate import Rbf
      >>> x, y, z, d = np.random.rand(4, 50)
      >>> rbfi = Rbf(x, y, z, d)  # radial basis function interpolator instance
      >>> xi = yi = zi = np.linspace(0, 1, 20)
      >>> di = rbfi(xi, yi, zi)   # interpolated values
      >>> di.shape
      (20,)

  Methods

  `__call__`(*args) |