colour.algebra.extrapolation Module — Colour 0.3.0 documentation

# colour.algebra.extrapolation Module

## Extrapolation

Defines classes for extrapolating variables:

- `Extrapolator1d`: 1-D function extrapolation.

class `colour.algebra.extrapolation.` `Extrapolator1d`(interpolator=None, method=u'Linear', left=None, right=None)

  Bases: `object`

  Extrapolates the 1-D function of given interpolator.

  The Extrapolator1d acts as a wrapper around a given Colour or scipy interpolator class instance with compatible signature. Two extrapolation methods are available:

  - Linear: Linearly extrapolates given points using the slope defined by the interpolator boundaries (xi[0], xi[1]) if x < xi[0] and (xi[-1], xi[-2]) if x > xi[-1].
  - Constant: Extrapolates given points by assigning the interpolator boundaries values xi[0] if x < xi[0] and xi[-1] if x > xi[-1].

  Specifying the left and right arguments takes precedence on the chosen extrapolation method and will assign the respective left and right values to the given points.

  Parameters: | interpolator (object) – Interpolator object. method (unicode, optional) – (‘Linear’, ‘Constant’), Extrapolation method. left (numeric, optional) – Value to return for x < xi[0]. right (numeric, optional) – Value to return for x > xi[-1].

  `__class__`()

  Notes

  The interpolator must define x and y attributes.

  References

  [1] | http://stackoverflow.com/a/2745496/931625 (Last accessed 8 August 2014)

  Examples

  Extrapolating a single numeric variable:

      >>> from colour.algebra import LinearInterpolator1d
      >>> x = np.array([3, 4, 5])
      >>> y = np.array([1, 2, 3])
      >>> interpolator = LinearInterpolator1d(x, y)
      >>> extrapolator = Extrapolator1d(interpolator)
      >>> extrapolator(1)
      -1.0

  Extrapolating an array_like variable:

      >>> extrapolator(np.array([6, 7 , 8]))
      array([ 4.,  5.,  6.])

  Using the Constant extrapolation method:

      >>> x = np.array([3, 4, 5])
      >>> y = np.array([1, 2, 3])
      >>> interpolator = LinearInterpolator1d(x, y)
      >>> extrapolator = Extrapolator1d(interpolator, method='Constant')
      >>> extrapolator(np.array([0.1, 0.2, 8, 9]))
      array([ 1.,  1.,  3.,  3.])

  Using defined left boundary and Constant extrapolation method:

      >>> x = np.array([3, 4, 5])
      >>> y = np.array([1, 2, 3])
      >>> interpolator = LinearInterpolator1d(x, y)
      >>> extrapolator = Extrapolator1d(interpolator, method='Constant', left=0)
      >>> extrapolator(np.array([0.1, 0.2, 8, 9]))
      array([ 0.,  0.,  3.,  3.])

  `__call__`(x)

    Evaluates the Extrapolator1d at given point(s).

    Parameters: | x (numeric or array_like) – Point(s) to evaluate the Extrapolator1d at.
    Returns: | Extrapolated points value(s).
    Return type: | float or ndarray

  `interpolator`

    Property for self.__interpolator private attribute.

    Returns: | self.__interpolator
    Return type: | object

  `left`

    Property for self.__left private attribute.

    Returns: | self.__left
    Return type: | numeric

  `method`

    Property for self.__method private attribute.

    Returns: | self.__method
    Return type: | unicode

  `right`

    Property for self.__right private attribute.

    Returns: | self.__right
    Return type: | numeric