# encoding: utf-8 # module scipy.interpolate._dierckx # from C:\Programs\Python\Python313\Lib\site-packages\scipy\interpolate\_dierckx.cp313-win_amd64.pyd # by generator 1.147 # no doc # no imports # functions def data_matrix(*args, **kwargs): # real signature unknown """ (m, k+1) array of non-zero b-splines """ pass def evaluate_all_bspl(t, k, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Evaluate the ``k+1`` B-splines which are non-zero on interval ``m``. Parameters ---------- t : ndarray, shape (nt + k + 1,) sorted 1D array of knots k : int spline order xval: float argument at which to evaluate the B-splines m : int index of the left edge of the evaluation interval, ``t[m] <= x < t[m+1]`` nu : int, optional Evaluate derivatives order `nu`. Default is zero. Returns ------- ndarray, shape (k+1,) The values of B-splines :math:`[B_{m-k}(xval), ..., B_{m}(xval)]` if `nu` is zero, otherwise the derivatives of order `nu`. Examples -------- A textbook use of this sort of routine is plotting the ``k+1`` polynomial pieces which make up a B-spline of order `k`. Consider a cubic spline >>> k = 3 >>> t = [0., 1., 2., 3., 4.] # internal knots >>> a, b = t[0], t[-1] # base interval is [a, b) >>> t = np.array([a]*k + t + [b]*k) # add boundary knots >>> import matplotlib.pyplot as plt >>> xx = np.linspace(a, b, 100) >>> plt.plot(xx, BSpline.basis_element(t[k:-k])(xx), ... lw=3, alpha=0.5, label='basis_element') Now we use slide an interval ``t[m]..t[m+1]`` along the base interval ``a..b`` and use `evaluate_all_bspl` to compute the restriction of the B-spline of interest to this interval: >>> for i in range(k+1): ... x1, x2 = t[2*k - i], t[2*k - i + 1] ... xx = np.linspace(x1 - 0.5, x2 + 0.5) ... yy = [evaluate_all_bspl(t, k, x, 2*k - i)[i] for x in xx] ... plt.plot(xx, yy, '--', label=str(i)) >>> plt.grid(True) >>> plt.legend() >>> plt.show() """ pass def evaluate_spline(*args, **kwargs): # real signature unknown """ Evaluate a spline in the B-spline basis. Parameters ---------- t : ndarray, shape (n+k+1) knots c : ndarray, shape (n, m) B-spline coefficients xp : ndarray, shape (s,) Points to evaluate the spline at. nu : int Order of derivative to evaluate. extrapolate : int, optional Whether to extrapolate to ouf-of-bounds points, or to return NaNs. out : ndarray, shape (s, m) Computed values of the spline at each of the input points. This argument is modified in-place. """ pass def find_interval(*args, **kwargs): # real signature unknown """ Find an interval such that t[interval] <= xval < t[interval+1]. Uses a linear search with locality, see fitpack's splev. Parameters ---------- t : ndarray, shape (nt,) Knots k : int B-spline degree xval : double value to find the interval for prev_l : int interval where the previous value was located. if unknown, use any value < k to start the search. extrapolate : int whether to return the last or the first interval if xval is out of bounds. Returns ------- interval : int Suitable interval or -1 if xval was nan. """ pass def fpback(*args, **kwargs): # real signature unknown """ backsubstitution, triangular matrix """ pass def fpknot(*args, **kwargs): # real signature unknown """ fpknot replacement """ pass def qr_reduce(*args, **kwargs): # real signature unknown """ row-by-row QR triangularization """ pass def _coloc(*args, **kwargs): # real signature unknown """ Build the B-spline colocation matrix. The colocation matrix is defined as :math:`B_{j,l} = B_l(x_j)`, so that row ``j`` contains all the B-splines which are non-zero at ``x_j``. The matrix is constructed in the LAPACK banded storage. Basically, for an N-by-N matrix A with ku upper diagonals and kl lower diagonals, the shape of the array Ab is (2*kl + ku +1, N), where the last kl+ku+1 rows of Ab contain the diagonals of A, and the first kl rows of Ab are not referenced. For more info see, e.g. the docs for the ``*gbsv`` routine. This routine is not supposed to be called directly, and does no error checking. Parameters ---------- x : ndarray, shape (n,) sorted 1D array of x values t : ndarray, shape (nt + k + 1,) sorted 1D array of knots k : int spline order ab : ndarray, shape (2*kl + ku + 1, nt), F-order This parameter is modified in-place. On exit: B-spline colocation matrix in the band storage with ``ku`` upper diagonals and ``kl`` lower diagonals. Here ``kl = ku = k``. offset : int, optional skip this many rows """ pass def _norm_eq_lsq(*args, **kwargs): # real signature unknown """ Construct the normal equations for the B-spline LSQ problem. The observation equations are ``A @ c = y``, and the normal equations are ``A.T @ A @ c = A.T @ y``. This routine fills in the rhs and lhs for the latter. The B-spline collocation matrix is defined as :math:`A_{j,l} = B_l(x_j)`, so that row ``j`` contains all the B-splines which are non-zero at ``x_j``. The normal eq matrix has at most `2k+1` bands and is constructed in the LAPACK symmetrix banded storage: ``A[i, j] == ab[i-j, j]`` with `i >= j`. See the doctsring for `scipy.linalg.cholesky_banded` for more info. Parameters ---------- x : ndarray, shape (n,) sorted 1D array of x values t : ndarray, shape (nt + k + 1,) sorted 1D array of knots k : int spline order y : ndarray, shape (n, s) a 2D array of y values. The second dimension contains all trailing dimensions of the original array of ordinates. w : ndarray, shape(n,) Weights. ab : ndarray, shape (k+1, n), in Fortran order. This parameter is modified in-place. On entry: should be zeroed out. On exit: LHS of the normal equations. rhs : ndarray, shape (n, s), in C order. This parameter is modified in-place. On entry: should be zeroed out. On exit: RHS of the normal equations. """ pass # no classes # variables with complex values __loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x0000024DFF930F50>' __spec__ = None # (!) real value is "ModuleSpec(name='scipy.interpolate._dierckx', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x0000024DFF930F50>, origin='C:\\\\Programs\\\\Python\\\\Python313\\\\Lib\\\\site-packages\\\\scipy\\\\interpolate\\\\_dierckx.cp313-win_amd64.pyd')"