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: c and t may be modified by the user. The Cython code expects
  that they are C contiguous.
docstr_tok: ["c","and","t","may","be","modified","by","the","user",".","The","Cython","code","expects","that","they","are","C","contiguous","."]
code: def _ensure_c_contiguous(self):
      """
      c and t may be modified by the user. The Cython code expects
      that they are C contiguous.
  
      """
      if not self.t.flags.c_contiguous:
          self.t = self.t.copy()
      if not self.c.flags.c_contiguous:
          self.c = self.c.copy()
  
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 7 for calling the BSpline obj's underlying member method code with example usage: obj._ensure_c_contiguous() without return types