class_docstr: Univariate spline in the B-spline basis.
  
  .. math::
  
      S(x) = \sum_{j=0}^{n-1} c_j  B_{j, k; t}(x)
  
  where :math:`B_{j, k; t}` are B-spline basis functions of degree `k`
  and knots `t`.
  
  Parameters
  ----------
  t : ndarray, shape (n+k+1,)
      knots
  c : ndarray, shape (>=n, ...)
      spline coefficients
  k : int
      B-spline order
  extrapolate : bool or 'periodic', optional
      whether to extrapolate beyond the base interval, ``t[k] .. t[n]``,
      or to return nans.
      If True, extrapolates the first and last polynomial pieces of b-spline
      functions active on the base interval.
      If 'periodic', periodic extrapolation is used.
      Default is True.
  axis : int, optional
      Interpolation axis. Default is zero.
  
  Attributes
  ----------
  t : ndarray
      knot vector
  c : ndarray
      spline coefficients
  k : int
      spline degree
  extrapolate : bool
      If True, extrapolates the first and last polynomial pieces of b-spline
      functions active on the base interval.
  axis : int
      Interpolation axis.
  tck : tuple
      A read-only equivalent of ``(self.t, self.c, self.k)``
  
  Methods
  -------
  __call__
  basis_element
  derivative
  antiderivative
  integrate
  construct_fast
  
  Notes
  -----
  B-spline basis elements are defined via
  
  .. math::
  
      B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,}
  
      B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x)
               + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)
  
  **Implementation details**
  
  - At least ``k+1`` coefficients are required for a spline of degree `k`,
    so that ``n >= k+1``. Additional coefficients, ``c[j]`` with
    ``j > n``, are ignored.
  
  - B-spline basis elements of degree `k` form a partition of unity on the
    *base interval*, ``t[k] <= x <= t[n]``.
  
  
  Examples
  --------
  
  Translating the recursive definition of B-splines into Python code, we have:
  
  >>> def B(x, k, i, t):
  ...    if k == 0:
  ...       return 1.0 if t[i] <= x < t[i+1] else 0.0
  ...    if t[i+k] == t[i]:
  ...       c1 = 0.0
  ...    else:
  ...       c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
  ...    if t[i+k+1] == t[i+1]:
  ...       c2 = 0.0
  ...    else:
  ...       c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
  ...    return c1 + c2
  
  >>> def bspline(x, t, c, k):
  ...    n = len(t) - k - 1
  ...    assert (n >= k+1) and (len(c) >= n)
  ...    return sum(c[i] * B(x, k, i, t) for i in range(n))
  
  Note that this is an inefficient (if straightforward) way to
  evaluate B-splines --- this spline class does it in an equivalent,
  but much more efficient way.
  
  Here we construct a quadratic spline function on the base interval
  ``2 <= x <= 4`` and compare with the naive way of evaluating the spline:
  
  >>> from scipy.interpolate import BSpline
  >>> k = 2
  >>> t = [0, 1, 2, 3, 4, 5, 6]
  >>> c = [-1, 2, 0, -1]
  >>> spl = BSpline(t, c, k)
  >>> spl(2.5)
  array(1.375)
  >>> bspline(2.5, t, c, k)
  1.375
  
  Note that outside of the base interval results differ. This is because
  `BSpline` extrapolates the first and last polynomial pieces of b-spline
  functions active on the base interval.
  
  >>> import matplotlib.pyplot as plt
  >>> fig, ax = plt.subplots()
  >>> xx = np.linspace(1.5, 4.5, 50)
  >>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
  >>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
  >>> ax.grid(True)
  >>> ax.legend(loc='best')
  >>> plt.show()
  
  
  References
  ----------
  .. [1] Tom Lyche and Knut Morken, Spline methods,
      http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/
  .. [2] Carl de Boor, A practical guide to splines, Springer, 2001.
docstr: Compute a definite integral of the spline.
  
  Parameters
  ----------
  a : float
      Lower limit of integration.
  b : float
      Upper limit of integration.
  extrapolate : bool or 'periodic', optional
      whether to extrapolate beyond the base interval,
      ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the
      base interval. If 'periodic', periodic extrapolation is used.
      If None (default), use `self.extrapolate`.
  
  Returns
  -------
  I : array_like
      Definite integral of the spline over the interval ``[a, b]``.
  
  Examples
  --------
  Construct the linear spline ``x if x < 1 else 2 - x`` on the base
  interval :math:`[0, 2]`, and integrate it
  
  >>> from scipy.interpolate import BSpline
  >>> b = BSpline.basis_element([0, 1, 2])
  >>> b.integrate(0, 1)
  array(0.5)
  
  If the integration limits are outside of the base interval, the result
  is controlled by the `extrapolate` parameter
  
  >>> b.integrate(-1, 1)
  array(0.0)
  >>> b.integrate(-1, 1, extrapolate=False)
  array(0.5)
  
  >>> import matplotlib.pyplot as plt
  >>> fig, ax = plt.subplots()
  >>> ax.grid(True)
  >>> ax.axvline(0, c='r', lw=5, alpha=0.5)  # base interval
  >>> ax.axvline(2, c='r', lw=5, alpha=0.5)
  >>> xx = [-1, 1, 2]
  >>> ax.plot(xx, b(xx))
  >>> plt.show()
docstr_tok: ["Compute","a","definite","integral","of","the","spline",".","Parameters","--","--","--","--","--","a",":","float","Lower","limit","of","integration",".","b",":","float","Upper","limit","of","integration",".","extrapolate",":","bool","or","'periodic","'",",","optional","whether","to","extrapolate","beyond","the","base","interval",",","``","t","[","k","]","..","t","[","-k-1","]","``",",","or","take","the","spline","to","be","zero","outside","of","the","base","interval",".","If","'periodic","'",",","periodic","extrapolation","is","used",".","If","None","(","default",")",",","use","`","self.extrapolate","`",".","Returns","--","--","--","-","I",":","array_like","Definite","integral","of","the","spline","over","the","interval","``","[","a",",","b","]","``",".","Examples","--","--","--","--","Construct","the","linear","spline","``","x","if","x","<","1","else","2","-","x","``","on","the","base","interval",":","math",":","`","[","0",",","2","]","`",",","and","integrate","it",">",">",">","from","scipy.interpolate","import","BSpline",">",">",">","b","=","BSpline.basis_element","(","[","0",",","1",",","2","]",")",">",">",">","b.integrate","(","0",",","1",")","array","(","0.5",")","If","the","integration","limits","are","outside","of","the","base","interval",",","the","result","is","controlled","by","the","`","extrapolate","`","parameter",">",">",">","b.integrate","(","-1",",","1",")","array","(","0.0",")",">",">",">","b.integrate","(","-1",",","1",",","extrapolate=False",")","array","(","0.5",")",">",">",">","import","matplotlib.pyplot","as","plt",">",">",">","fig",",","ax","=","plt.subplots","(",")",">",">",">","ax.grid","(","True",")",">",">",">","ax.axvline","(","0",",","c=","'","r","'",",","lw=5",",","alpha=0.5",")","#","base","interval",">",">",">","ax.axvline","(","2",",","c=","'","r","'",",","lw=5",",","alpha=0.5",")",">",">",">","xx","=","[","-1",",","1",",","2","]",">",">",">","ax.plot","(","xx",",","b","(","xx",")",")",">",">",">","plt.show","(",")"]
code: def integrate(self, a, b, extrapolate=None):
      """Compute a definite integral of the spline.
  
      Parameters
      ----------
      a : float
          Lower limit of integration.
      b : float
          Upper limit of integration.
      extrapolate : bool or 'periodic', optional
          whether to extrapolate beyond the base interval,
          ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the
          base interval. If 'periodic', periodic extrapolation is used.
          If None (default), use `self.extrapolate`.
  
      Returns
      -------
      I : array_like
          Definite integral of the spline over the interval ``[a, b]``.
  
      Examples
      --------
      Construct the linear spline ``x if x < 1 else 2 - x`` on the base
      interval :math:`[0, 2]`, and integrate it
  
      >>> from scipy.interpolate import BSpline
      >>> b = BSpline.basis_element([0, 1, 2])
      >>> b.integrate(0, 1)
      array(0.5)
  
      If the integration limits are outside of the base interval, the result
      is controlled by the `extrapolate` parameter
  
      >>> b.integrate(-1, 1)
      array(0.0)
      >>> b.integrate(-1, 1, extrapolate=False)
      array(0.5)
  
      >>> import matplotlib.pyplot as plt
      >>> fig, ax = plt.subplots()
      >>> ax.grid(True)
      >>> ax.axvline(0, c='r', lw=5, alpha=0.5)  # base interval
      >>> ax.axvline(2, c='r', lw=5, alpha=0.5)
      >>> xx = [-1, 1, 2]
      >>> ax.plot(xx, b(xx))
      >>> plt.show()
  
      """
      if extrapolate is None:
          extrapolate = self.extrapolate
  
      # Prepare self.t and self.c.
      self._ensure_c_contiguous()
  
      # Swap integration bounds if needed.
      sign = 1
      if b < a:
          a, b = b, a
          sign = -1
      n = self.t.size - self.k - 1
  
      if extrapolate != "periodic" and not extrapolate:
          # Shrink the integration interval, if needed.
          a = max(a, self.t[self.k])
          b = min(b, self.t[n])
  
          if self.c.ndim == 1:
              # Fast path: use FITPACK's routine
              # (cf _fitpack_impl.splint).
              t, c, k = self.tck
              integral, wrk = _dierckx._splint(t, c, k, a, b)
              return integral * sign
  
      out = np.empty((2, prod(self.c.shape[1:])), dtype=self.c.dtype)
  
      # Compute the antiderivative.
      c = self.c
      ct = len(self.t) - len(c)
      if ct > 0:
          c = np.r_[c, np.zeros((ct,) + c.shape[1:])]
      ta, ca, ka = _fitpack_impl.splantider((self.t, c, self.k), 1)
  
      if extrapolate == "periodic":
          # Split the integral into the part over period (can be several
          # of them) and the remaining part.
  
          ts, te = self.t[self.k], self.t[n]
          period = te - ts
          interval = b - a
          n_periods, left = divmod(interval, period)
  
          if n_periods > 0:
              # Evaluate the difference of antiderivatives.
              x = np.asarray([ts, te], dtype=np.float_)
              _bspl.evaluate_spline(
                  ta, ca.reshape(ca.shape[0], -1), ka, x, 0, False, out
              )
              integral = out[1] - out[0]
              integral *= n_periods
          else:
              integral = np.zeros(
                  (1, prod(self.c.shape[1:])), dtype=self.c.dtype
              )
  
          # Map a to [ts, te], b is always a + left.
          a = ts + (a - ts) % period
          b = a + left
  
          # If b <= te then we need to integrate over [a, b], otherwise
          # over [a, te] and from xs to what is remained.
          if b <= te:
              x = np.asarray([a, b], dtype=np.float_)
              _bspl.evaluate_spline(
                  ta, ca.reshape(ca.shape[0], -1), ka, x, 0, False, out
              )
              integral += out[1] - out[0]
          else:
              x = np.asarray([a, te], dtype=np.float_)
              _bspl.evaluate_spline(
                  ta, ca.reshape(ca.shape[0], -1), ka, x, 0, False, out
              )
              integral += out[1] - out[0]
  
              x = np.asarray([ts, ts + b - te], dtype=np.float_)
              _bspl.evaluate_spline(
                  ta, ca.reshape(ca.shape[0], -1), ka, x, 0, False, out
              )
              integral += out[1] - out[0]
      else:
          # Evaluate the difference of antiderivatives.
          x = np.asarray([a, b], dtype=np.float_)
          _bspl.evaluate_spline(
              ta,
              ca.reshape(ca.shape[0], -1),
              ka,
              x,
              0,
              extrapolate,
              out,
          )
          integral = out[1] - out[0]
  
      integral *= sign
      return integral.reshape(ca.shape[1:])
  
imports: from __future__ import division, print_function, absolute_import
  import functools
  import operator
  import numpy
  from scipy._lib.six import string_types
  from scipy.linalg import get_lapack_funcs, LinAlgError, cholesky_banded, cho_solve_banded
  from .None import _bspl
  from .None import _fitpack_impl
  from .None import _fitpack
label_desc: Use image node_id 10 for calling the BSpline obj's underlying member method code with example usage: obj.integrate(a, b, extrapolate) and returns: integral, unknown