scipy 1.15.3__cp313-cp313t-win_amd64.whl → 1.16.0rc2__cp313-cp313t-win_amd64.whl

scipy/interpolate/_bsplines.py

@@ -237,8 +237,7 @@ class BSpline:
         if self.t.ndim != 1:
             raise ValueError("Knot vector must be one-dimensional.")
         if n < self.k + 1:
-            raise ValueError("Need at least %d knots for degree %d" %
-                             (2*k + 2, k))
+            raise ValueError(f"Need at least {2*k + 2} knots for degree {k}")
         if (np.diff(self.t) < 0).any():
             raise ValueError("Knots must be in a non-decreasing order.")
         if len(np.unique(self.t[k:n+1])) < 2:
@@ -503,25 +502,33 @@ class BSpline:
         # [self.t[k], self.t[n]].
         if extrapolate == 'periodic':
             n = self.t.size - self.k - 1
-            x = self.t[self.k] + (x - self.t[self.k]) % (self.t[n] -
-                                                         self.t[self.k])
+            x = self.t[self.k] + (x - self.t[self.k]) % (self.t[n] - self.t[self.k])
             extrapolate = False
 
-        out = np.empty((len(x), prod(self.c.shape[1:])), dtype=self.c.dtype)
         self._ensure_c_contiguous()
 
-        # if self.c is complex, so is `out`; cython code in _bspl.pyx expectes
-        # floats though, so make a view---this expands the last axis, and
+        # if self.c is complex: the C code in _dierckxmodule.cc expects
+        # floats, so make a view---this expands the last axis, and
         # the view is C contiguous if the original is.
         # if c.dtype is complex of shape (n,), c.view(float).shape == (2*n,)
         # if c.dtype is complex of shape (n, m), c.view(float).shape == (n, 2*m)
 
-        cc = self.c.view(float)
-        if self.c.ndim == 1 and self.c.dtype.kind == 'c':
-            cc = cc.reshape(self.c.shape[0], 2)
+        is_complex = self.c.dtype.kind == 'c'
+        if is_complex:
+            cc = self.c.view(float)
+            if self.c.ndim == 1:
+                cc = cc.reshape(self.c.shape[0], 2)
+        else:
+            cc = self.c
+
+        # flatten the trailing dims
+        cc = cc.reshape(cc.shape[0], -1)
 
-        _dierckx.evaluate_spline(self.t, cc.reshape(cc.shape[0], -1),
-                              self.k, x, nu, extrapolate, out.view(float))
+        # heavy lifting: actually perform the evaluations
+        out = _dierckx.evaluate_spline(self.t, cc, self.k, x, nu, extrapolate)
+
+        if is_complex:
+            out = out.view(complex)
 
         out = out.reshape(x_shape + self.c.shape[1:])
         if self.axis != 0:
@@ -553,7 +560,7 @@ class BSpline:
 
         Returns
         -------
-        b : BSpline object
+        b : `BSpline` object
             A new instance representing the derivative.
 
         See Also
@@ -580,7 +587,7 @@ class BSpline:
 
         Returns
         -------
-        b : BSpline object
+        b : `BSpline` object
             A new instance representing the antiderivative.
 
         Notes
@@ -682,8 +689,6 @@ class BSpline:
                 integral = _fitpack_impl.splint(a, b, self.tck)
                 return np.asarray(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)
@@ -703,8 +708,8 @@ class BSpline:
             if n_periods > 0:
                 # Evaluate the difference of antiderivatives.
                 x = np.asarray([ts, te], dtype=np.float64)
-                _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
-                                      ka, x, 0, False, out)
+                out = _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
+                                      ka, x, 0, False)
                 integral = out[1] - out[0]
                 integral *= n_periods
             else:
@@ -719,24 +724,24 @@ class BSpline:
             # over [a, te] and from xs to what is remained.
             if b <= te:
                 x = np.asarray([a, b], dtype=np.float64)
-                _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
-                                      ka, x, 0, False, out)
+                out = _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
+                                      ka, x, 0, False)
                 integral += out[1] - out[0]
             else:
                 x = np.asarray([a, te], dtype=np.float64)
-                _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
-                                      ka, x, 0, False, out)
+                out = _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
+                                      ka, x, 0, False)
                 integral += out[1] - out[0]
 
                 x = np.asarray([ts, ts + b - te], dtype=np.float64)
-                _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
-                                      ka, x, 0, False, out)
+                out = _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
+                                      ka, x, 0, False)
                 integral += out[1] - out[0]
         else:
             # Evaluate the difference of antiderivatives.
             x = np.asarray([a, b], dtype=np.float64)
-            _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
-                                  ka, x, 0, extrapolate, out)
+            out = _dierckx.evaluate_spline(ta, ca.reshape(ca.shape[0], -1),
+                                  ka, x, 0, extrapolate)
             integral = out[1] - out[0]
 
         integral *= sign
@@ -763,7 +768,7 @@ class BSpline:
 
         Returns
         -------
-        b : BSpline object
+        b : `BSpline` object
             A new instance representing the initial polynomial
             in the B-spline basis.
 
@@ -865,8 +870,8 @@ class BSpline:
 
         Returns
         -------
-        spl : BSpline object
-            A new BSpline object with the new knot inserted.
+        spl : `BSpline` object
+            A new `BSpline` object with the new knot inserted.
 
         Notes
         -----
@@ -1287,7 +1292,8 @@ def _make_periodic_spline(x, y, t, k, axis):
 
     Returns
     -------
-    b : a BSpline object of the degree ``k`` and with knots ``t``.
+    b : `BSpline` object
+        A `BSpline` object of the degree ``k`` and with knots ``t``.
 
     Notes
     -----
@@ -1362,7 +1368,7 @@ def _make_periodic_spline(x, y, t, k, axis):
 
 def make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0,
                        check_finite=True):
-    """Compute the (coefficients of) interpolating B-spline.
+    """Create an interpolating B-spline with specified degree and boundary conditions.
 
     Parameters
     ----------
@@ -1407,7 +1413,8 @@ def make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0,
 
     Returns
     -------
-    b : a BSpline object of the degree ``k`` and with knots ``t``.
+    b : `BSpline` object
+        A `BSpline` object of the degree ``k`` and with knots ``t``.
 
     See Also
     --------
@@ -1565,8 +1572,7 @@ def make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0,
     if t.ndim != 1 or np.any(t[1:] < t[:-1]):
         raise ValueError("Expect t to be a 1-D sorted array_like.")
     if t.size < x.size + k + 1:
-        raise ValueError('Got %d knots, need at least %d.' %
-                         (t.size, x.size + k + 1))
+        raise ValueError(f"Got {t.size} knots, need at least {x.size + k + 1}.")
     if (x[0] < t[k]) or (x[-1] > t[-k]):
         raise ValueError(f'Out of bounds w/ x = {x}.')
 
@@ -1632,15 +1638,13 @@ def make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0,
     if info > 0:
         raise LinAlgError("Colocation matrix is singular.")
     elif info < 0:
-        raise ValueError('illegal value in %d-th argument of internal gbsv' % -info)
-
+        raise ValueError(f'illegal value in {-info}-th argument of internal gbsv')
     c = np.ascontiguousarray(c.reshape((nt,) + y.shape[1:]))
     return BSpline.construct_fast(t, c, k, axis=axis)
 
 
 def make_lsq_spline(x, y, t, k=3, w=None, axis=0, check_finite=True, *, method="qr"):
-    r"""Compute the (coefficients of) an LSQ (Least SQuared) based
-    fitting B-spline.
+    r"""Create a smoothing B-spline satisfying the Least SQuares (LSQ) criterion.
 
     The result is a linear combination
 
@@ -1684,7 +1688,8 @@ def make_lsq_spline(x, y, t, k=3, w=None, axis=0, check_finite=True, *, method="
 
     Returns
     -------
-    b : a BSpline object of the degree ``k`` with knots ``t``.
+    b : `BSpline` object
+        A `BSpline` object of the degree ``k`` with knots ``t``.
 
     See Also
     --------
@@ -1762,6 +1767,9 @@ def make_lsq_spline(x, y, t, k=3, w=None, axis=0, check_finite=True, *, method="
     axis = normalize_axis_index(axis, y.ndim)
 
     y = np.moveaxis(y, axis, 0)    # now internally interp axis is zero
+    if not y.flags.c_contiguous:
+        # C routines in _dierckx currently require C contiguity
+        y = y.copy(order='C')
 
     if x.ndim != 1:
         raise ValueError("Expect x to be a 1-D sequence.")
@@ -1825,8 +1833,9 @@ def make_lsq_spline(x, y, t, k=3, w=None, axis=0, check_finite=True, *, method="
         # have observation matrix & rhs, can solve the LSQ problem
         cho_decomp = cholesky_banded(ab, overwrite_ab=True, lower=lower,
                                      check_finite=check_finite)
-        c = cho_solve_banded((cho_decomp, lower), rhs, overwrite_b=True,
-                             check_finite=check_finite)
+        m = rhs.shape[0]
+        c = cho_solve_banded((cho_decomp, lower), rhs.reshape(m, -1), overwrite_b=True,
+                             check_finite=check_finite).reshape(rhs.shape)
     elif method == "qr":
         _, _, c = _lsq_solve_qr(x, yy, t, k, w)
 
@@ -2011,7 +2020,7 @@ def _compute_optimal_gcv_parameter(X, wE, y, w):
         B[0] = [0.] * n
         return B
 
-    def _gcv(lam, X, XtWX, wE, XtE):
+    def _gcv(lam, X, XtWX, wE, XtE, y):
         r"""
         Computes the generalized cross-validation criteria [1].
 
@@ -2096,14 +2105,29 @@ def _compute_optimal_gcv_parameter(X, wE, y, w):
     XtWX = compute_banded_symmetric_XT_W_Y(X, w, X)
     XtE = compute_banded_symmetric_XT_W_Y(X, w, wE)
 
-    def fun(lam):
-        return _gcv(lam, X, XtWX, wE, XtE)
-
-    gcv_est = minimize_scalar(fun, bounds=(0, n), method='Bounded')
-    if gcv_est.success:
-        return gcv_est.x
-    raise ValueError(f"Unable to find minimum of the GCV "
-                     f"function: {gcv_est.message}")
+    if y.ndim == 1:
+        gcv_est = minimize_scalar(
+            _gcv, bounds=(0, n), method='Bounded', args=(X, XtWX, wE, XtE, y)
+        )
+        if gcv_est.success:
+            return gcv_est.x
+        raise ValueError(f"Unable to find minimum of the GCV "
+                         f"function: {gcv_est.message}")
+    elif y.ndim == 2:
+        gcv_est = np.empty(y.shape[1])
+        for i in range(y.shape[1]):
+            est = minimize_scalar(
+                _gcv, bounds=(0, n), method='Bounded', args=(X, XtWX, wE, XtE, y[:, i])
+            )
+            if est.success:
+               gcv_est[i] = est.x
+            else:
+                raise ValueError(f"Unable to find minimum of the GCV "
+                                 f"function: {gcv_est.message}")
+        return gcv_est 
+    else:
+        # trailing dims must have been flattened already.
+        raise RuntimeError("Internal error. Please report it to scipy developers.")
 
 
 def _coeff_of_divided_diff(x):
@@ -2139,8 +2163,10 @@ def _coeff_of_divided_diff(x):
     return res
 
 
-def make_smoothing_spline(x, y, w=None, lam=None):
+def make_smoothing_spline(x, y, w=None, lam=None, *, axis=0):
     r"""
+    Create a smoothing B-spline satisfying the Generalized Cross Validation (GCV) criterion.
+
     Compute the (coefficients of) smoothing cubic spline function using
     ``lam`` to control the tradeoff between the amount of smoothness of the
     curve and its proximity to the data. In case ``lam`` is None, using the
@@ -2167,18 +2193,22 @@ def make_smoothing_spline(x, y, w=None, lam=None):
     ----------
     x : array_like, shape (n,)
         Abscissas. `n` must be at least 5.
-    y : array_like, shape (n,)
+    y : array_like, shape (n, ...)
         Ordinates. `n` must be at least 5.
     w : array_like, shape (n,), optional
         Vector of weights. Default is ``np.ones_like(x)``.
     lam : float, (:math:`\lambda \geq 0`), optional
         Regularization parameter. If ``lam`` is None, then it is found from
         the GCV criteria. Default is None.
+    axis : int, optional
+        The data axis. Default is zero.
+        The assumption is that ``y.shape[axis] == n``, and all other axes of ``y``
+        are batching axes.
 
     Returns
     -------
-    func : a BSpline object.
-        A callable representing a spline in the B-spline basis
+    func : `BSpline` object
+        An object representing a spline in the B-spline basis
         as a solution of the problem of smoothing splines using
         the GCV criteria [1] in case ``lam`` is None, otherwise using the
         given parameter ``lam``.
@@ -2241,13 +2271,13 @@ def make_smoothing_spline(x, y, w=None, lam=None):
 
     >>> import matplotlib.pyplot as plt
     >>> grid = np.linspace(x[0], x[-1], 400)
+    >>> plt.plot(x, y, '.')
     >>> plt.plot(grid, spl(grid), label='Spline')
     >>> plt.plot(grid, func(grid), label='Original function')
-    >>> plt.scatter(x, y, marker='.')
     >>> plt.legend(loc='best')
     >>> plt.show()
 
-    """
+    """  # noqa:E501
 
     x = np.ascontiguousarray(x, dtype=float)
     y = np.ascontiguousarray(y, dtype=float)
@@ -2255,9 +2285,8 @@ def make_smoothing_spline(x, y, w=None, lam=None):
     if any(x[1:] - x[:-1] <= 0):
         raise ValueError('``x`` should be an ascending array')
 
-    if x.ndim != 1 or y.ndim != 1 or x.shape[0] != y.shape[0]:
-        raise ValueError('``x`` and ``y`` should be one dimensional and the'
-                         ' same size')
+    if x.ndim != 1 or x.shape[0] != y.shape[axis]:
+        raise ValueError(f'``x`` should be 1D and {x.shape = } == {y.shape = }')
 
     if w is None:
         w = np.ones(len(x))
@@ -2272,6 +2301,15 @@ def make_smoothing_spline(x, y, w=None, lam=None):
     if n <= 4:
         raise ValueError('``x`` and ``y`` length must be at least 5')
 
+    # Internals assume that the data axis is the zero-th axis
+    axis = normalize_axis_index(axis, y.ndim)
+    y = np.moveaxis(y, axis, 0)
+
+    # flatten the trailing axes of y to simplify further manipulations
+    y_shape1 = y.shape[1:]
+    if y_shape1 != ():
+        y = y.reshape((n, -1))
+
     # It is known that the solution to the stated minimization problem exists
     # and is a natural cubic spline with vector of knots equal to the unique
     # elements of ``x`` [3], so we will solve the problem in the basis of
@@ -2316,15 +2354,30 @@ def make_smoothing_spline(x, y, w=None, lam=None):
         raise ValueError('Regularization parameter should be non-negative')
 
     # solve the initial problem in the basis of natural splines
-    c = solve_banded((2, 2), X + lam * wE, y)
+    if np.ndim(lam) == 0:
+        c = solve_banded((2, 2), X + lam * wE, y)
+    elif np.ndim(lam) == 1:
+        # XXX: solve_banded does not suppport batched `ab` matrices; loop manually
+        c = np.empty((n, lam.shape[0]))
+        for i in range(lam.shape[0]):
+            c[:, i] = solve_banded((2, 2), X + lam[i] * wE, y[:, i])
+    else:
+        # this should not happen, ever
+        raise RuntimeError("Internal error, please report it to SciPy developers.")
+    c = c.reshape((c.shape[0], *y_shape1))
+
+    # hack: these are c[0], c[1] etc, shape-compatible with np.r_ below
+    c0, c1 = c[0:1, ...], c[1:2, ...]     # c[0], c[1]
+    cm0, cm1 = c[-1:-2:-1, ...], c[-2:-3:-1, ...]    # c[-1], c[-2]
+
     # move back to B-spline basis using equations (2.2.10) [4]
-    c_ = np.r_[c[0] * (t[5] + t[4] - 2 * t[3]) + c[1],
-               c[0] * (t[5] - t[3]) + c[1],
-               c[1: -1],
-               c[-1] * (t[-4] - t[-6]) + c[-2],
-               c[-1] * (2 * t[-4] - t[-5] - t[-6]) + c[-2]]
+    c_ = np.r_[c0 * (t[5] + t[4] - 2 * t[3]) + c1,
+               c0 * (t[5] - t[3]) + c1,
+               c[1: -1, ...],
+               cm0 * (t[-4] - t[-6]) + cm1,
+               cm0 * (2 * t[-4] - t[-5] - t[-6]) + cm1]
 
-    return BSpline.construct_fast(t, c_, 3)
+    return BSpline.construct_fast(t, c_, 3, axis=axis)
 
 
 ########################

scipy/interpolate/_cubic.py

@@ -70,7 +70,7 @@ def prepare_input(x, y, axis, dydx=None):
 
 
 class CubicHermiteSpline(PPoly):
-    """Piecewise-cubic interpolator matching values and first derivatives.
+    """Piecewise cubic interpolator to fit values and first derivatives (C1 smooth).
 
     The result is represented as a `PPoly` instance.
 
@@ -115,6 +115,7 @@ class CubicHermiteSpline(PPoly):
     derivative
     antiderivative
     integrate
+    solve
     roots
 
     See Also
@@ -157,7 +158,7 @@ class CubicHermiteSpline(PPoly):
 
 
 class PchipInterpolator(CubicHermiteSpline):
-    r"""PCHIP 1-D monotonic cubic interpolation.
+    r"""PCHIP shape-preserving interpolator (C1 smooth).
 
     ``x`` and ``y`` are arrays of values used to approximate some function f,
     with ``y = f(x)``. The interpolant uses monotonic cubic splines
@@ -185,8 +186,11 @@ class PchipInterpolator(CubicHermiteSpline):
     __call__
     derivative
     antiderivative
+    integrate
+    solve
     roots
 
+
     See Also
     --------
     CubicHermiteSpline : Piecewise-cubic interpolator.
@@ -327,12 +331,6 @@ def pchip_interpolate(xi, yi, x, der=0, axis=0):
         A 1-D array of real values. `yi`'s length along the interpolation
         axis must be equal to the length of `xi`. If N-D array, use axis
         parameter to select correct axis.
-
-        .. deprecated:: 1.13.0
-            Complex data is deprecated and will raise an error in
-            SciPy 1.15.0. If you are trying to use the real components of
-            the passed array, use ``np.real`` on `yi`.
-
     x : scalar or array_like
         Of length M.
     der : int or list, optional
@@ -378,8 +376,7 @@ def pchip_interpolate(xi, yi, x, der=0, axis=0):
 
 
 class Akima1DInterpolator(CubicHermiteSpline):
-    r"""
-    Akima interpolator
+    r"""Akima "visually pleasing" interpolator (C1 smooth).
 
     Fit piecewise cubic polynomials, given vectors x and y. The interpolation
     method by Akima uses a continuously differentiable sub-spline built from
@@ -404,15 +401,17 @@ class Akima1DInterpolator(CubicHermiteSpline):
         .. versionadded:: 1.13.0
 
     extrapolate : {bool, None}, optional
-        If bool, determines whether to extrapolate to out-of-bounds points 
-        based on first and last intervals, or to return NaNs. If None, 
+        If bool, determines whether to extrapolate to out-of-bounds points
+        based on first and last intervals, or to return NaNs. If None,
         ``extrapolate`` is set to False.
-        
+
     Methods
     -------
     __call__
     derivative
     antiderivative
+    integrate
+    solve
     roots
 
     See Also
@@ -489,7 +488,7 @@ class Akima1DInterpolator(CubicHermiteSpline):
 
     """
 
-    def __init__(self, x, y, axis=0, *, method: Literal["akima", "makima"]="akima", 
+    def __init__(self, x, y, axis=0, *, method: Literal["akima", "makima"]="akima",
                  extrapolate:bool | None = None):
         if method not in {"akima", "makima"}:
             raise NotImplementedError(f"`method`={method} is unsupported.")
@@ -507,37 +506,45 @@ class Akima1DInterpolator(CubicHermiteSpline):
         # Akima extrapolation historically False; parent class defaults to True.
         extrapolate = False if extrapolate is None else extrapolate
 
-        # determine slopes between breakpoints
-        m = np.empty((x.size + 3, ) + y.shape[1:])
-        dx = dx[(slice(None), ) + (None, ) * (y.ndim - 1)]
-        m[2:-2] = np.diff(y, axis=0) / dx
-
-        # add two additional points on the left ...
-        m[1] = 2. * m[2] - m[3]
-        m[0] = 2. * m[1] - m[2]
-        # ... and on the right
-        m[-2] = 2. * m[-3] - m[-4]
-        m[-1] = 2. * m[-2] - m[-3]
-
-        # if m1 == m2 != m3 == m4, the slope at the breakpoint is not
-        # defined. This is the fill value:
-        t = .5 * (m[3:] + m[:-3])
-        # get the denominator of the slope t
-        dm = np.abs(np.diff(m, axis=0))
-        if method == "makima":
-            pm = np.abs(m[1:] + m[:-1])
-            f1 = dm[2:] + 0.5 * pm[2:]
-            f2 = dm[:-2] + 0.5 * pm[:-2]
+        if y.shape[0] == 2:
+            # edge case: only have two points, use linear interpolation
+            xp = x.reshape((x.shape[0],) + (1,)*(y.ndim-1))
+            hk = xp[1:] - xp[:-1]
+            mk = (y[1:] - y[:-1]) / hk
+            t = np.zeros_like(y)
+            t[...] = mk
         else:
-            f1 = dm[2:]
-            f2 = dm[:-2]
-        f12 = f1 + f2
-        # These are the mask of where the slope at breakpoint is defined:
-        ind = np.nonzero(f12 > 1e-9 * np.max(f12, initial=-np.inf))
-        x_ind, y_ind = ind[0], ind[1:]
-        # Set the slope at breakpoint
-        t[ind] = (f1[ind] * m[(x_ind + 1,) + y_ind] +
-                  f2[ind] * m[(x_ind + 2,) + y_ind]) / f12[ind]
+            # determine slopes between breakpoints
+            m = np.empty((x.size + 3, ) + y.shape[1:])
+            dx = dx[(slice(None), ) + (None, ) * (y.ndim - 1)]
+            m[2:-2] = np.diff(y, axis=0) / dx
+
+            # add two additional points on the left ...
+            m[1] = 2. * m[2] - m[3]
+            m[0] = 2. * m[1] - m[2]
+            # ... and on the right
+            m[-2] = 2. * m[-3] - m[-4]
+            m[-1] = 2. * m[-2] - m[-3]
+
+            # if m1 == m2 != m3 == m4, the slope at the breakpoint is not
+            # defined. This is the fill value:
+            t = .5 * (m[3:] + m[:-3])
+            # get the denominator of the slope t
+            dm = np.abs(np.diff(m, axis=0))
+            if method == "makima":
+                pm = np.abs(m[1:] + m[:-1])
+                f1 = dm[2:] + 0.5 * pm[2:]
+                f2 = dm[:-2] + 0.5 * pm[:-2]
+            else:
+                f1 = dm[2:]
+                f2 = dm[:-2]
+            f12 = f1 + f2
+            # These are the mask of where the slope at breakpoint is defined:
+            ind = np.nonzero(f12 > 1e-9 * np.max(f12, initial=-np.inf))
+            x_ind, y_ind = ind[0], ind[1:]
+            # Set the slope at breakpoint
+            t[ind] = (f1[ind] * m[(x_ind + 1,) + y_ind] +
+                    f2[ind] * m[(x_ind + 2,) + y_ind]) / f12[ind]
 
         super().__init__(x, y, t, axis=0, extrapolate=extrapolate)
         self.axis = axis
@@ -560,7 +567,7 @@ class Akima1DInterpolator(CubicHermiteSpline):
 
 
 class CubicSpline(CubicHermiteSpline):
-    """Cubic spline data interpolator.
+    """Piecewise cubic interpolator to fit values (C2 smooth).
 
     Interpolate data with a piecewise cubic polynomial which is twice
     continuously differentiable [1]_. The result is represented as a `PPoly`
@@ -636,6 +643,7 @@ class CubicSpline(CubicHermiteSpline):
     derivative
     antiderivative
     integrate
+    solve
     roots
 
     See Also
@@ -774,8 +782,9 @@ class CubicSpline(CubicHermiteSpline):
                 b[1] = 3 * (dxr[0] * slope[1] + dxr[1] * slope[0])
                 b[2] = 2 * slope[1]
 
-                s = solve(A, b, overwrite_a=True, overwrite_b=True,
-                          check_finite=False)
+                m = b.shape[0]
+                s = solve(A, b.reshape(m, -1), overwrite_a=True, overwrite_b=True,
+                          check_finite=False).reshape(b.shape)
             elif n == 3 and bc[0] == 'periodic':
                 # In case when number of points is 3 we compute the derivatives
                 # manually
@@ -835,11 +844,15 @@ class CubicSpline(CubicHermiteSpline):
                     b2[-1] = -a_m2_m1
 
                     # s1 and s2 are the solutions of (n-2, n-2) system
-                    s1 = solve_banded((1, 1), Ac, b1, overwrite_ab=False,
+                    m = b1.shape[0]
+                    s1 = solve_banded((1, 1), Ac, b1.reshape(m, -1), overwrite_ab=False,
                                       overwrite_b=False, check_finite=False)
+                    s1 = s1.reshape(b1.shape)
 
-                    s2 = solve_banded((1, 1), Ac, b2, overwrite_ab=False,
+                    m = b2.shape[0]
+                    s2 = solve_banded((1, 1), Ac, b2.reshape(m, -1), overwrite_ab=False,
                                       overwrite_b=False, check_finite=False)
+                    s2 = s2.reshape(b2.shape)
 
                     # computing the s[n-2] solution:
                     s_m1 = ((b[-1] - a_m1_0 * s1[0] - a_m1_m2 * s1[-1]) /
@@ -881,8 +894,10 @@ class CubicSpline(CubicHermiteSpline):
                         A[-1, -2] = dx[-1]
                         b[-1] = 0.5 * bc_end[1] * dx[-1]**2 + 3 * (y[-1] - y[-2])
 
-                    s = solve_banded((1, 1), A, b, overwrite_ab=True,
+                    m = b.shape[0]
+                    s = solve_banded((1, 1), A, b.reshape(m, -1), overwrite_ab=True,
                                      overwrite_b=True, check_finite=False)
+                    s = s.reshape(b.shape)
 
         super().__init__(x, y, s, axis=0, extrapolate=extrapolate)
         self.axis = axis