sdkagent

scipy API reference

400 public APIs from scipy (scipy/scipy) — 143 classes, 166 functions, 91 methods. Signatures extracted by static analysis of the actual source.

Repository: scipy/scipy

KindCount
Classes143
Functions166
Methods91

API list

func.spin.cmds.bench(ctx, tests, submodule, compare, verbose, quick, commits, array_api_backend, dry_run, build, build_dir, *args, **kwargs)
🔧 Run benchmarks.
func.spin.cmds.notes(ctx_obj, version_args)
Release notes and log generation.
func.spin.cmds.refguide_check(ctx, build_dir, *args, **kwargs)
🔧 Run refguide check.
classscipy._external.packaging_version.src.version.InvalidVersion
Raised when a version string is not a valid version.
classscipy._external.packaging_version.src.version.Version
This class abstracts handling of a project's versions.
methodscipy._external.packaging_version.src.version.Version.base_version() -> str
The "base version" of the version.
methodscipy._external.packaging_version.src.version.Version.dev() -> int | None
The development number of the version.
methodscipy._external.packaging_version.src.version.Version.epoch() -> int
The epoch of the version.
methodscipy._external.packaging_version.src.version.Version.is_devrelease() -> bool
Whether this version is a development release.
methodscipy._external.packaging_version.src.version.Version.is_postrelease() -> bool
Whether this version is a post-release.
methodscipy._external.packaging_version.src.version.Version.is_prerelease() -> bool
Whether this version is a pre-release.
methodscipy._external.packaging_version.src.version.Version.local() -> str | None
The local version segment of the version.
methodscipy._external.packaging_version.src.version.Version.post() -> int | None
The post-release number of the version.
methodscipy._external.packaging_version.src.version.Version.pre() -> tuple[str, int] | None
The pre-release segment of the version.
methodscipy._external.packaging_version.src.version.Version.public() -> str
The public portion of the version.
funcscipy._external.packaging_version.src.version.parse(version:str) -> Version
Parse the given version string.
funcscipy._lib._array_api.get_native_namespace_name(xp:ModuleType) -> str
Return name for native namespace (without array_api_compat prefix).
funcscipy._lib._array_api.xp_compat_namespace(xp:ModuleType | None) -> ModuleType
Return the array-api-compat(ible) namespace corresponding to `xp`.
funcscipy._lib._array_api.xp_copy(x:Array, *xp:ModuleType | None=None) -> Array
Copies an array.
funcscipy._lib._array_api_docs_tables.calculate_table_statistics(flat_table:list[dict[str, str]]) -> dict[str, dict[str, int]]
Get counts of what is supported per module.
funcscipy._lib._array_api_override.array_namespace(*sparse_ok=False, *arrays:Array) -> ModuleType
Get the array API compatible namespace for the arrays xs.
classscipy._lib._ccallback.LowLevelCallable
Low-level callback function.
funcscipy._lib._docscrape.NumpyDocString.parse_item_name(text)
Match ':role:`name`' or 'name'.
classscipy._lib._docscrape.Reader
A line-based string reader.
funcscipy._lib._docscrape.dedent_lines(lines)
Deindent a list of lines maximally
funcscipy._lib._gcutils.set_gc_state(state)
Set status of garbage collector
funcscipy._lib._sparse.issparse(x)
Is `x` either sparse array or sparse matrix type?
classscipy._lib._testutils.FPUModeChangeWarning
Warning about FPU mode change
funcscipy._lib._util.broadcastable(shape_a:tuple[int, ...], shape_b:tuple[int, ...]) -> bool
Check if two shapes are broadcastable.
classscipy._lib.doccer.Decorator
A decorator of a function.
funcscipy._lib.doccer.docformat(docstring:str, docdict:Mapping[str, str] | None=None) -> str
Fill a function docstring from variables in dictionary.
funcscipy._lib.doccer.filldoc(docdict:Mapping[str, str], unindent_params:bool=True) -> Decorator
Return docstring decorator using docdict variable dictionary.
funcscipy._lib.doccer.unindent_dict(docdict:Mapping[str, str]) -> dict[str, str]
Unindent all strings in a docdict.
funcscipy._lib.doccer.unindent_string(docstring:str) -> str
Set docstring to minimum indent for all lines, including first.
classscipy.cluster.hierarchy._hierarchy_impl.ClusterNode
A tree node class for representing a cluster.
classscipy.cluster.hierarchy._hierarchy_impl.ClusterWarning
A ``UserWarning`` raised during clustering.
funcscipy.cluster.hierarchy._hierarchy_impl.centroid(y)
Perform centroid/UPGMC linkage.
funcscipy.cluster.hierarchy._hierarchy_impl.leaves_list(Z)
Return a list of leaf node ids.
funcscipy.cluster.hierarchy._hierarchy_impl.median(y)
Perform median/WPGMC linkage.
classscipy.cluster.vq._vq_impl.ClusterError
An ``Exception`` raised during clustering.
classscipy.constants._codata.ConstantWarning
Accessing a constant no longer in current CODATA data set.
funcscipy.constants._codata.find(sub:str | None=None, disp:bool=False) -> Any
Return list of physical_constant keys containing a given string.
funcscipy.constants._codata.precision(key:str) -> float
Relative precision in physical_constants indexed by key.
funcscipy.constants._codata.unit(key:str) -> str
Unit in physical_constants indexed by key.
funcscipy.constants._codata.value(key:str) -> float
Value in physical_constants indexed by key.
funcscipy.constants._constants.lambda2nu(lambda_:'npt.ArrayLike') -> Any
Convert wavelength to optical frequency.
funcscipy.constants._constants.nu2lambda(nu:'npt.ArrayLike') -> Any
Convert optical frequency to wavelength.
funcscipy.fft._backend.register_backend(backend)
Register a backend for permanent use.
funcscipy.fft._backend.set_global_backend(backend, coerce=False, only=False, try_last=False)
Sets the global fft backend.
classscipy.fft._debug_backends.EchoBackend
Backend that just prints the __ua_function__ arguments
classscipy.fft._debug_backends.NumPyBackend
Backend that uses numpy.fft
funcscipy.fft._fftlog.fht(a, dln, mu, offset=0.0, bias=0.0)
Compute the fast Hankel transform.
funcscipy.fft._helper.ifftshift(x, axes=None)
The inverse of `fftshift`.
funcscipy.fftpack._basic.fft2(x, shape=None, axes=(-2, -1), overwrite_x=False)
2-D discrete Fourier transform.
funcscipy.integrate._bvp.collocation_fun(fun, y, p, x, h)
Evaluate collocation residuals.
funcscipy.integrate._bvp.modify_mesh(x, insert_1, insert_2)
Insert nodes into a mesh.
classscipy.integrate._ivp.base.ConstantDenseOutput
Constant value interpolator.
classscipy.integrate._ivp.base.DenseOutput
Base class for local interpolant over step made by an ODE solver.
classscipy.integrate._ivp.base.OdeSolver
Base class for ODE solvers.
methodscipy.integrate._ivp.base.OdeSolver.step()
Perform one integration step.
classscipy.integrate._ivp.bdf.BDF
Implicit method based on backward-differentiation formulas.
classscipy.integrate._ivp.common.OdeSolution
Continuous ODE solution.
funcscipy.integrate._ivp.common.norm(x)
Compute RMS norm.
funcscipy.integrate._ivp.common.validate_tol(rtol, atol, n)
Validate tolerance values.
classscipy.integrate._ivp.radau.Radau
Implicit Runge-Kutta method of Radau IIA family of order 5.
classscipy.integrate._ivp.rk.DOP853
Explicit Runge-Kutta method of order 8.
classscipy.integrate._ivp.rk.RK23
Explicit Runge-Kutta method of order 3(2).
classscipy.integrate._ivp.rk.RK45
Explicit Runge-Kutta method of order 5(4).
classscipy.integrate._ivp.rk.RungeKutta
Base class for explicit Runge-Kutta methods.
funcscipy.integrate._ivp.rk.rk_step(fun, t, y, f, h, A, B, C, K)
Perform a single Runge-Kutta step.
funcscipy.integrate._lebedev.lebedev_rule(n)
Lebedev quadrature.
classscipy.integrate._ode.complex_ode
A wrapper of ode for complex systems.
methodscipy.integrate._ode.complex_ode.set_initial_value(y, t=0.0)
Set initial conditions y(t) = y.
methodscipy.integrate._ode.complex_ode.set_integrator(name, **integrator_params)
Set integrator by name.
classscipy.integrate._ode.ode
A generic interface class to numeric integrators.
methodscipy.integrate._ode.ode.set_initial_value(y, t=0.0)
Set initial conditions y(t) = y.
methodscipy.integrate._ode.ode.set_integrator(name, **integrator_params)
Set integrator by name.
methodscipy.integrate._ode.ode.successful()
Check if integration was successful.
classscipy.integrate._odepack_py.ODEintWarning
Warning raised during the execution of `odeint`.
classscipy.integrate._quad_vec.DoubleInfiniteFunc
Argument transform from (-oo, oo) to (-1, 1)
classscipy.integrate._quad_vec.SemiInfiniteFunc
Argument transform from (start, +-oo) to (0, 1)
classscipy.integrate._quadpack_py.IntegrationWarning
Warning on issues during integration.
funcscipy.integrate._quadpack_py.dblquad(func, a, b, gfun, hfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)
Compute a double integral.
classscipy.integrate._rules._base.Rule
Base class for numerical integration algorithms (cubatures).
classscipy.integrate._rules._gauss_kronrod.GaussKronrodQuadrature
Gauss-Kronrod quadrature.
classscipy.integrate._rules._gauss_legendre.GaussLegendreQuadrature
Gauss-Legendre quadrature.
classscipy.integrate._rules._genz_malik.GenzMalikCubature
Genz-Malik cubature.
classscipy.interpolate._bary_rational.AAA
AAA real or complex rational approximation.
classscipy.interpolate._bsplines.BSpline
Univariate spline in the B-spline basis.
classscipy.interpolate._cubic.Akima1DInterpolator
Akima "visually pleasing" interpolator (C1 smooth).
classscipy.interpolate._cubic.CubicSpline
Piecewise cubic interpolator to fit values (C2 smooth).
classscipy.interpolate._cubic.PchipInterpolator
PCHIP shape-preserving interpolator (C1 smooth).
classscipy.interpolate._fitpack2.BivariateSpline
Base class for bivariate splines.
methodscipy.interpolate._fitpack2.BivariateSpline.ev(xi, yi, dx=0, dy=0)
Evaluate the spline at points.
classscipy.interpolate._fitpack2.LSQBivariateSpline
Weighted least-squares bivariate spline approximation.
classscipy.interpolate._fitpack2.LSQUnivariateSpline
1-D spline with explicit internal knots.
classscipy.interpolate._fitpack2.RectBivariateSpline
Bivariate spline approximation over a rectangular mesh.
classscipy.interpolate._fitpack2.SmoothBivariateSpline
Smooth bivariate spline approximation.
classscipy.interpolate._fitpack2.UnivariateSpline
1-D smoothing spline fit to a given set of data points.
methodscipy.interpolate._fitpack2.UnivariateSpline.get_coeffs()
Return spline coefficients.
methodscipy.interpolate._fitpack2.UnivariateSpline.roots()
Return the zeros of the spline.
funcscipy.interpolate._fitpack_py.insert(x, tck, m=1, per=0)
Insert knots into a B-spline.
funcscipy.interpolate._fitpack_py.sproot(tck, mest=10)
Find the roots of a cubic B-spline.
classscipy.interpolate._fitpack_repro.F
The r.h.s.
classscipy.interpolate._fitpack_repro.Fperiodic
Fit a smooth periodic B-spline curve to given data points.
funcscipy.interpolate._fitpack_repro.add_knot(x, t, k, residuals, periodic=False)
Add a new knot.
classscipy.interpolate._interpolate.BPoly
Piecewise polynomial in the Bernstein basis.
classscipy.interpolate._interpolate.NdPPoly
Piecewise tensor product polynomial.
classscipy.interpolate._interpolate.PPoly
Piecewise polynomial in the power basis.
classscipy.interpolate._interpolate.interp1d
Interpolate a 1-D function (legacy).
methodscipy.interpolate._interpolate.interp1d.fill_value()
The fill value.
classscipy.interpolate._ndbspline.NdBSpline
Tensor product spline object.
classscipy.interpolate._ndgriddata.NearestNDInterpolator
Nearest-neighbor interpolator in N > 1 dimensions.
classscipy.interpolate._polyint.KroghInterpolator
Krogh interpolator (C∞ smooth).
classscipy.interpolate._rbfinterp.RBFInterpolator
Radial basis function interpolator in N ≥ 1 dimensions.
classscipy.io._fortran.FortranEOFError
Indicates that the file ended properly.
methodscipy.io._fortran.FortranFile.close()
Closes the file.
classscipy.io._fortran.FortranFormattingError
Indicates that the file ended mid-record.
classscipy.io._harwell_boeing._fortran_format_parser.FortranFormatParser
Parser for Fortran format strings.
classscipy.io._harwell_boeing.hb.HBMatrixType
Class to hold the matrix type.
funcscipy.io._harwell_boeing.hb.hb_read(path_or_open_file, *spmatrix=_NoValue)
Read HB-format file.
funcscipy.io._harwell_boeing.hb.hb_write(path_or_open_file, m, hb_info=None)
Write HB-format file.
classscipy.io._idl.ObjectPointer
Class used to define object pointers
classscipy.io._idl.Pointer
Class used to define pointers
funcscipy.io._idl.readsav(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)
Read an IDL .sav file.
classscipy.io._netcdf.netcdf_file
A file object for NetCDF data.
methodscipy.io._netcdf.netcdf_file.close()
Closes the NetCDF file.
classscipy.io._netcdf.netcdf_variable
A data object for netcdf files.
methodscipy.io._netcdf.netcdf_variable.itemsize()
Return the itemsize of the variable.
methodscipy.io._netcdf.netcdf_variable.typecode()
Return the typecode of the variable.
classscipy.io.arff._arffread.ArffError
Base exception for errors when reading ARFF files.
methodscipy.io.arff._arffread.Attribute.parse_data(data_str)
Parse a value of this type.
classscipy.io.arff._arffread.MetaData
Small container to keep useful information on an ARFF dataset.
methodscipy.io.arff._arffread.MetaData.names()
Return the list of attribute names.
methodscipy.io.arff._arffread.MetaData.types()
Return the list of attribute types.
classscipy.io.arff._arffread.ParseArffError
Exception for syntax and parsing errors in ARFF files.
funcscipy.io.arff._arffread.loadarff(f)
Read an arff file.
funcscipy.io.arff._arffread.read_header(ofile)
Read the header of the iterable ofile.
funcscipy.io.matlab._mio.loadmat(file_name, mdict=None, appendmat=True, *spmatrix=_NoValue, **kwargs)
Load MATLAB file.
funcscipy.io.matlab._mio.whosmat(file_name, appendmat=True, **kwargs)
List variables inside a MATLAB file.
classscipy.io.matlab._mio4.MatFile4Reader
Reader for Mat4 files
methodscipy.io.matlab._mio4.MatFile4Reader.list_variables()
list variables from stream
classscipy.io.matlab._mio4.MatFile4Writer
Class for writing matlab 4 format files
classscipy.io.matlab._mio4.VarReader4
Class to read matlab 4 variables
methodscipy.io.matlab._mio4.VarReader4.read_header()
Read and return header for variable
classscipy.io.matlab._mio5.EmptyStructMarker
Class to indicate presence of empty matlab struct on output
classscipy.io.matlab._mio5.MatFile5Writer
Class for writing mat5 files
classscipy.io.matlab._mio5.VarWriter5
Generic matlab matrix writing class
methodscipy.io.matlab._mio5.VarWriter5.write_element(arr, mdtype=None)
write tag and data
methodscipy.io.matlab._mio5.VarWriter5.write_sparse(arr)
Sparse matrices are 2D
classscipy.io.matlab._mio5_params.MatlabFunction
Subclass for a MATLAB function.
classscipy.io.matlab._mio5_params.MatlabObject
Subclass of ndarray to signal this is a matlab object.
classscipy.io.matlab._mio5_params.MatlabOpaque
Subclass for a MATLAB opaque matrix.
classscipy.io.matlab._mio5_params.mat_struct
Placeholder for holding read data from structs.
classscipy.io.matlab._miobase.MatReadError
Exception indicating a read issue.
classscipy.io.matlab._miobase.MatReadWarning
Warning class for read issues.
classscipy.io.matlab._miobase.MatVarReader
Abstract class defining required interface for var readers
methodscipy.io.matlab._miobase.MatVarReader.array_from_header(header)
Reads array given header
methodscipy.io.matlab._miobase.MatVarReader.read_header()
Returns header
classscipy.io.matlab._miobase.MatWriteError
Exception indicating a write issue.
classscipy.io.matlab._miobase.MatWriteWarning
Warning class for write issues.
funcscipy.io.matlab._miobase.arr_to_chars(arr)
Convert string array to char array
funcscipy.io.wavfile.read(filename, mmap=False)
Open a WAV file.
funcscipy.io.wavfile.write(filename, rate, data)
Write a NumPy array as a WAV file.
funcscipy.linalg._basic.det(a, overwrite_a=False, check_finite=True)
Compute the determinant of a matrix.
funcscipy.linalg._decomp_polar.polar(a, side='right')
Compute the polar decomposition.
funcscipy.linalg._matfuncs.coshm(A)
Compute the hyperbolic matrix cosine.
funcscipy.linalg._matfuncs.cosm(A)
Compute the matrix cosine.
funcscipy.linalg._matfuncs.expm(A)
Compute the matrix exponential of an array.
funcscipy.linalg._matfuncs.khatri_rao(a, b)
Khatri-Rao product of two matrices.
funcscipy.linalg._matfuncs.logm(A)
Compute matrix logarithm.
funcscipy.linalg._matfuncs.signm(A)
Matrix sign function.
funcscipy.linalg._matfuncs.sinhm(A)
Compute the hyperbolic matrix sine.
funcscipy.linalg._matfuncs.sinm(A)
Compute the matrix sine.
funcscipy.linalg._matfuncs.sqrtm(A)
Compute, if exists, the matrix square root.
funcscipy.linalg._matfuncs.tanhm(A)
Compute the hyperbolic matrix tangent.
funcscipy.linalg._matfuncs.tanm(A)
Compute the matrix tangent.
funcscipy.linalg._misc.norm(a, ord=None, axis=None, keepdims=False, check_finite=True)
Matrix or vector norm.
funcscipy.linalg._special_matrices.circulant(c)
Construct a circulant matrix.
funcscipy.linalg._special_matrices.companion(a)
Create a companion matrix.
funcscipy.linalg._special_matrices.convolution_matrix(a, n, mode='full')
Construct a convolution matrix.
funcscipy.linalg._special_matrices.dft(n, scale=None)
Discrete Fourier transform matrix.
funcscipy.linalg._special_matrices.fiedler(a)
Returns a symmetric Fiedler matrix.
funcscipy.linalg._special_matrices.fiedler_companion(a)
Returns a Fiedler companion matrix.
funcscipy.linalg._special_matrices.hadamard(n, dtype=int)
Construct a Hadamard matrix.
funcscipy.linalg._special_matrices.hankel(c, r=None)
Construct a Hankel matrix.
funcscipy.linalg._special_matrices.helmert(n, full=False)
Create a Helmert matrix of order `n`.
funcscipy.linalg._special_matrices.hilbert(n)
Create a Hilbert matrix of order `n`.
funcscipy.linalg._special_matrices.leslie(f, s)
Create a Leslie matrix.
funcscipy.linalg._special_matrices.pascal(n, kind='symmetric', exact=True)
Returns the n x n Pascal matrix.
funcscipy.linalg._special_matrices.toeplitz(c, r=None)
Construct a Toeplitz matrix.
funcscipy.linalg.blas.find_best_blas_type(arrays=(), dtype=None)
Find best-matching BLAS/LAPACK type.
funcscipy.linalg.interpolative.id_to_svd(B, idx, proj)
Convert ID to SVD.
funcscipy.linalg.interpolative.interp_decomp(A, eps_or_k, rand=True, rng=None)
Compute ID of a matrix.
funcscipy.linalg.interpolative.reconstruct_matrix_from_id(B, idx, proj)
Reconstruct matrix from its ID.
funcscipy.linalg.interpolative.svd(A, eps_or_k, rand=True, rng=None)
Compute SVD of a matrix via an ID.
funcscipy.ndimage._filters.prewitt(input, axis=-1, output=None, mode='reflect', cval=0.0)
Calculate a Prewitt filter.
funcscipy.ndimage._filters.sobel(input, axis=-1, output=None, mode='reflect', cval=0.0)
Calculate a Sobel filter.
funcscipy.ndimage._interpolation.rotate(input, angle, axes=(1, 0), reshape=True, output=None, order=3, mode='constant', cval=0.0, prefilter=True)
Rotate an array.
funcscipy.ndimage._interpolation.shift(input, shift, output=None, order=3, mode='constant', cval=0.0, prefilter=True)
Shift an array.
funcscipy.ndimage._interpolation.spline_filter(input, order=3, output=np.float64, mode='mirror')
Multidimensional spline filter.
funcscipy.ndimage._interpolation.zoom(input, zoom, output=None, order=3, mode='constant', cval=0.0, prefilter=True, *grid_mode=False)
Zoom an array.
funcscipy.ndimage._measurements.do_map(inputs, output)
labels must be sorted
funcscipy.ndimage._measurements.find_objects(input, max_label=0)
Find objects in a labeled array.
funcscipy.ndimage._measurements.label(input, structure=None, output=None)
Label features in an array.
funcscipy.ndimage._measurements.sum(input, labels=None, index=None)
Calculate the sum of the values of the array.
funcscipy.ndimage._measurements.sum_labels(input, labels=None, index=None)
Calculate the sum of the values of the array.
classscipy.optimize._basinhopping.AdaptiveStepsize
Class to implement adaptive stepsize.
classscipy.optimize._basinhopping.Metropolis
Metropolis acceptance criterion.
classscipy.optimize._basinhopping.MinimizerWrapper
wrap a minimizer function as a minimizer class
classscipy.optimize._basinhopping.Storage
Class used to store the lowest energy structure
classscipy.optimize._constraints.Bounds
Bounds constraint on the variables.
classscipy.optimize._constraints.LinearConstraint
Linear constraint on the variables.
classscipy.optimize._constraints.NonlinearConstraint
Nonlinear constraint on the variables.
classscipy.optimize._constraints.PreparedConstraint
Constraint prepared from a user defined constraint.
classscipy.optimize._differentiable_functions.IdentityVectorFunction
Identity vector function and its derivatives.
classscipy.optimize._differentiable_functions.LinearVectorFunction
Linear vector function and its derivatives.
classscipy.optimize._differentiable_functions.ScalarFunction
Scalar function and its derivatives.
classscipy.optimize._differentiable_functions.VectorFunction
Vector function and its derivatives.
classscipy.optimize._dual_annealing.EnergyState
Class used to record the energy state.
classscipy.optimize._hessian_update_strategy.HessianUpdateStrategy
Interface for implementing Hessian update strategies.
methodscipy.optimize._hessian_update_strategy.HessianUpdateStrategy.initialize(n, approx_type)
Initialize internal matrix.
methodscipy.optimize._hessian_update_strategy.HessianUpdateStrategy.update(delta_x, delta_grad)
Update internal matrix.
classscipy.optimize._hessian_update_strategy.SR1
Symmetric-rank-1 Hessian update strategy.
funcscipy.optimize._isotonic.isotonic_regression(y:'npt.ArrayLike', *weights:'npt.ArrayLike | None'=None, *increasing:bool=True) -> OptimizeResult
Nonparametric isotonic regression.
funcscipy.optimize._lsq.common.in_bounds(x, lb, ub)
Check if a point lies within bounds.
funcscipy.optimize._lsq.common.left_multiplied_operator(J, d)
Return diag(d) J as LinearOperator.
funcscipy.optimize._lsq.common.left_multiply(J, d, copy=True)
Compute diag(d) J.
funcscipy.optimize._lsq.common.phi_and_derivative(alpha, suf, s, Delta)
Function of which to find zero.
funcscipy.optimize._lsq.common.right_multiplied_operator(J, d)
Return J diag(d) as LinearOperator.
funcscipy.optimize._lsq.common.right_multiply(J, d, copy=True)
Compute J diag(d).
classscipy.optimize._nonlin.Anderson
Find a root of a function, using (extended) Anderson mixing.
classscipy.optimize._nonlin.Jacobian
Common interface for Jacobians or Jacobian approximations.
classscipy.optimize._nonlin.LowRankMatrix
A matrix represented as ..
methodscipy.optimize._nonlin.LowRankMatrix.matvec(v)
Evaluate w = M v
methodscipy.optimize._nonlin.LowRankMatrix.rmatvec(v)
Evaluate w = M^H v
methodscipy.optimize._nonlin.LowRankMatrix.rsolve(v, tol=0)
Evaluate w = M^-H v
methodscipy.optimize._nonlin.LowRankMatrix.solve(v, tol=0)
Evaluate w = M^-1 v
classscipy.optimize._nonlin.TerminationCondition
Termination condition for an iteration.
classscipy.optimize._optimize.OptimizeResult
Represents the optimization result.
classscipy.optimize._optimize.OptimizeWarning
General warning for :mod:`scipy.optimize`.
funcscipy.optimize._optimize.rosen(x)
The Rosenbrock function.
funcscipy.optimize._optimize.rosen_der(x)
The derivative (i.e.
classscipy.optimize._shgo_lib._vertex.FieldWrapper
Object to wrap field to pass to `multiprocessing.Pool`.
classscipy.optimize._shgo_lib._vertex.VertexBase
Base class for a vertex.
classscipy.optimize._shgo_lib._vertex.VertexCacheBase
Base class for a vertex cache for a simplicial complex.
methodscipy.optimize._shgo_lib._vertex.VertexCacheBase.size()
Returns the size of the vertex cache.
classscipy.optimize._trustregion_constr.minimize_trustregion_constr.HessianLinearOperator
Build LinearOperator from hessp
funcscipy.optimize._trustregion_constr.qp_subproblem.inside_box_boundaries(x, lb, ub)
Check if lb <= x <= ub.
funcscipy.optimize._trustregion_constr.qp_subproblem.reinforce_box_boundaries(x, lb, ub)
Return clipped value of x
classscipy.optimize._trustregion_dogleg.DoglegSubproblem
Quadratic subproblem solved by the dogleg method
funcscipy.optimize._tstutils.aps03_f(x, a, b)
Rapidly changing at the root
funcscipy.optimize._tstutils.aps04_f(x, n, a)
Medium-degree polynomial
funcscipy.optimize._tstutils.aps05_f(x)
Simple Trigonometric function
funcscipy.optimize._tstutils.aps08_f(x, n)
Degree n polynomial
funcscipy.optimize._tstutils.aps10_f(x, n)
Exponential plus a polynomial
funcscipy.optimize._tstutils.aps12_f(x, n)
nth root of x, with a zero at x=n
funcscipy.optimize._tstutils.cplx01_f(z, n, a)
z**n-a: Use to find the nth root of a
funcscipy.optimize._tstutils.cplx02_f(z, a)
e**z - a: Use to find the log of a
funcscipy.optimize._tstutils.f1(x)
f1 is a quadratic with roots at 0 and 1
funcscipy.optimize._tstutils.f2(x)
f2 is a symmetric parabola, x**2 - 1
funcscipy.optimize._tstutils.f3(x)
A quartic with roots at 0, 1, 2 and 3
classscipy.optimize._zeros_py.RootResults
Represents the root finding result.
classscipy.signal._czt.CZT
Create a callable chirp z-transform function.
classscipy.signal._czt.ZoomFFT
Create a callable zoom FFT transform function.
classscipy.signal._filter_design.BadCoefficients
Warning about badly conditioned filter coefficients.
funcscipy.signal._filter_design.G(w)
Gain of filter
funcscipy.signal._filter_design.cutoff(w)
When gain = -3 dB, return 0
funcscipy.signal._filter_design.gammatone(freq, ftype, order=None, numtaps=None, fs=None, *xp=None, *device=None)
Gammatone filter design.
funcscipy.signal._lti_conversion.ss2tf(A, B, C, D, input=0)
State-space to transfer function.
classscipy.signal._ltisys.StateSpace
Linear Time Invariant system in state-space form.
methodscipy.signal._ltisys.StateSpace.A()
State matrix of the `StateSpace` system.
methodscipy.signal._ltisys.StateSpace.B()
Input matrix of the `StateSpace` system.
methodscipy.signal._ltisys.StateSpace.C()
Output matrix of the `StateSpace` system.
classscipy.signal._ltisys.TransferFunction
Linear Time Invariant system class in transfer function form.
classscipy.signal._ltisys.ZerosPolesGain
Linear Time Invariant system class in zeros, poles, gain form.
methodscipy.signal._ltisys.ZerosPolesGain.gain()
Gain of the `ZerosPolesGain` system.
methodscipy.signal._ltisys.ZerosPolesGain.poles()
Poles of the `ZerosPolesGain` system.
methodscipy.signal._ltisys.ZerosPolesGain.zeros()
Zeros of the `ZerosPolesGain` system.
funcscipy.signal._ltisys.dimpulse(system, x0=None, t=None, n=None)
Impulse response of discrete-time system.
classscipy.signal._ltisys.dlti
Discrete-time linear time invariant system base class.
methodscipy.signal._ltisys.dlti.dt()
Return the sampling time of the system.
funcscipy.signal._ltisys.dstep(system, x0=None, t=None, n=None)
Step response of discrete-time system.
classscipy.signal._ltisys.lti
Continuous-time linear time invariant system base class.
funcscipy.signal._polyutils.polyroots(coef, *xp)
numpy.roots, best-effor replacement
funcscipy.signal._polyutils.polyval(p, x, *xp)
Old-style polynomial, `np.polyval`
funcscipy.signal._signaltools.convolve(in1, in2, mode='full', method='auto')
Convolve two N-dimensional arrays.
funcscipy.signal._signaltools.medfilt2d(input, kernel_size=3)
Median filter a 2-dimensional array.
funcscipy.signal._waveforms.square(t, duty=0.5)
Return a periodic square-wave waveform.
funcscipy.signal.windows._windows.bartlett(M, sym=True, *xp=None, *device=None)
Return a Bartlett window.
funcscipy.signal.windows._windows.blackman(M, sym=True, *xp=None, *device=None)
Return a Blackman window.
funcscipy.signal.windows._windows.bohman(M, sym=True, *xp=None, *device=None)
Return a Bohman window.
funcscipy.signal.windows._windows.chebwin(M, at, sym=True, *xp=None, *device=None)
Return a Dolph-Chebyshev window.
funcscipy.signal.windows._windows.flattop(M, sym=True, *xp=None, *device=None)
Return a flat top window.
funcscipy.signal.windows._windows.gaussian(M, std, sym=True, *xp=None, *device=None)
Return a Gaussian window.
funcscipy.signal.windows._windows.hamming(M, sym=True, *xp=None, *device=None)
Return a Hamming window.
funcscipy.signal.windows._windows.hann(M, sym=True, *xp=None, *device=None)
Return a Hann window.
funcscipy.signal.windows._windows.kaiser(M, beta, sym=True, *xp=None, *device=None)
Return a Kaiser window.
funcscipy.signal.windows._windows.parzen(M, sym=True, *xp=None, *device=None)
Return a Parzen window.
funcscipy.signal.windows._windows.taylor(M, nbar=4, sll=30, norm=True, sym=True, *xp=None, *device=None)
Return a Taylor window.
funcscipy.signal.windows._windows.triang(M, sym=True, *xp=None, *device=None)
Return a triangular window.
classscipy.sparse._base.SparseWarning
General warning for :mod:`scipy.sparse`.
funcscipy.sparse._base.isspmatrix(x)
Is `x` of a sparse matrix type?
classscipy.sparse._base.sparray
A namespace class to separate sparray from spmatrix.
classscipy.sparse._bsr.bsr_array
Block Sparse Row format sparse array.
classscipy.sparse._bsr.bsr_matrix
Block Sparse Row format sparse matrix.
funcscipy.sparse._bsr.isspmatrix_bsr(x)
Is `x` of a bsr_matrix type?
funcscipy.sparse._construct.expand_dims(A, *axis=0)
Add trivial axes to an array.
funcscipy.sparse._construct.identity(n, dtype='d', format=None)
Identity matrix in sparse format.
funcscipy.sparse._construct.matrix_transpose(A)
Return the matrix transpose of `A`.
funcscipy.sparse._construct.swapaxes(A, axis1, axis2)
Interchange two axes of an array.
classscipy.sparse._coo.coo_array
A sparse array in COOrdinate format.
classscipy.sparse._coo.coo_matrix
A sparse matrix in COOrdinate format.
funcscipy.sparse._coo.isspmatrix_coo(x)
Is `x` of coo_matrix type?
classscipy.sparse._csc.csc_array
Compressed Sparse Column array.
classscipy.sparse._csc.csc_matrix
Compressed Sparse Column matrix.
funcscipy.sparse._csc.isspmatrix_csc(x)
Is `x` of csc_matrix type?
classscipy.sparse._csr.csr_array
Compressed Sparse Row array.
classscipy.sparse._csr.csr_matrix
Compressed Sparse Row matrix.
funcscipy.sparse._csr.isspmatrix_csr(x)
Is `x` of csr_matrix type?
classscipy.sparse._dia.dia_array
Sparse array with DIAgonal storage.
classscipy.sparse._dia.dia_matrix
Sparse matrix with DIAgonal storage.
funcscipy.sparse._dia.isspmatrix_dia(x)
Is `x` of dia_matrix type?
classscipy.sparse._dok.dok_array
Dictionary Of Keys based sparse array.
classscipy.sparse._dok.dok_matrix
Dictionary Of Keys based sparse matrix.
methodscipy.sparse._dok.dok_matrix.get_shape()
Get shape of a sparse matrix.
funcscipy.sparse._dok.isspmatrix_dok(x)
Is `x` of dok_array type?
funcscipy.sparse._lil.isspmatrix_lil(x)
Is `x` of lil_matrix type?
classscipy.sparse._lil.lil_array
Row-based LIst of Lists sparse array.
classscipy.sparse._lil.lil_matrix
Row-based LIst of Lists sparse matrix.
classscipy.sparse._matrix.spmatrix
This class provides a base class for all sparse matrix classes.
methodscipy.sparse._matrix.spmatrix.get_shape()
Get the shape of the matrix
methodscipy.sparse._matrix.spmatrix.getformat()
Matrix storage format
methodscipy.sparse._matrix.spmatrix.set_shape(shape)
Set the shape of the matrix in-place
funcscipy.sparse._sputils.get_sum_dtype(dtype:np.dtype) -> np.dtype | type[np.generic]
Mimic numpy's casting for np.sum
funcscipy.sparse._sputils.isintlike(x) -> bool
Is x appropriate as an index into a sparse matrix?
funcscipy.sparse._sputils.isscalarlike(x) -> bool
Is x either a scalar, an array scalar, or a 0-dim array?
funcscipy.sparse._sputils.isshape(x, nonneg=False, *allow_nd=(2,), *check_nd=True) -> bool
Is x a valid tuple of dimensions?
classscipy.sparse.linalg._dsolve.linsolve.MatrixRankWarning
Warning for exactly singular matrices.
classscipy.sparse.linalg._eigen.arpack.arpack.ArpackError
ARPACK error.
classscipy.sparse.linalg._eigen.arpack.arpack.ArpackNoConvergence
ARPACK iteration did not converge.
classscipy.sparse.linalg._expm_multiply.LazyOperatorNormInfo
Information about an operator is lazily computed.
methodscipy.sparse.linalg._expm_multiply.LazyOperatorNormInfo.onenorm()
Compute the exact 1-norm.
methodscipy.sparse.linalg._expm_multiply.LazyOperatorNormInfo.set_scale(scale)
Set the scale parameter.
classscipy.sparse.linalg._interface.LinearOperator
Common interface for performing matrix vector products.
methodscipy.sparse.linalg._interface.LinearOperator.H()
Hermitian adjoint.
methodscipy.sparse.linalg._interface.LinearOperator.T()
Transpose.
methodscipy.sparse.linalg._interface.LinearOperator.adjoint()
Hermitian adjoint.
methodscipy.sparse.linalg._interface.LinearOperator.dot(x)
Multi-purpose multiplication method.
methodscipy.sparse.linalg._interface.LinearOperator.matmat(X)
Matrix-matrix multiplication.
methodscipy.sparse.linalg._interface.LinearOperator.matvec(x)
Matrix-vector multiplication.
methodscipy.sparse.linalg._interface.LinearOperator.transpose()
Transpose.
classscipy.sparse.linalg._interface.MatrixLinearOperator
Operator defined by a matrix `A` which implements ``@``.
funcscipy.sparse.linalg._interface.aslinearoperator(A)
Return `A` as a `LinearOperator`.
funcscipy.sparse.linalg._matfuncs.inv(A)
Compute the inverse of a sparse arrays.
funcscipy.sparse.linalg._norm.norm(x, ord=None, axis=None)
Norm of a sparse matrix.
funcscipy.spatial._geometric_slerp.geometric_slerp(start:'npt.ArrayLike', end:'npt.ArrayLike', t:'npt.ArrayLike', tol:float=1e-07) -> np.ndarray
Geometric spherical linear interpolation.
classscipy.spatial._kdtree.KDTree
kd-tree for quick nearest-neighbor lookup.
classscipy.spatial._kdtree.Rectangle
Hyperrectangle class.
methodscipy.spatial._kdtree.Rectangle.split(d, split)
Produce two hyperrectangles by splitting.
funcscipy.spatial._kdtree.distance_matrix(x, y, p=2.0, threshold=1000000)
Compute the distance matrix.
classscipy.spatial._spherical_voronoi.SphericalVoronoi
Voronoi diagrams on the surface of a sphere.
funcscipy.spatial.distance._distance.chebyshev(u, v, w=None)
Compute the Chebyshev distance.
classscipy.spatial.transform._rigid_transform.RigidTransform
Rigid transform in 3 dimensions.
methodscipy.spatial.transform._rigid_transform.RigidTransform.apply(vector:ArrayLike, inverse:bool=False) -> Array
Apply the transform to a vector.
methodscipy.spatial.transform._rigid_transform.RigidTransform.from_dual_quat(dual_quat:ArrayLike, *scalar_first:bool=False) -> RigidTransform
Initialize from a unit dual quaternion.
methodscipy.spatial.transform._rigid_transform.RigidTransform.from_exp_coords(exp_coords:ArrayLike) -> RigidTransform
Initialize from exponential coordinates of transform.
methodscipy.spatial.transform._rigid_transform.RigidTransform.from_matrix(matrix:ArrayLike) -> RigidTransform
Initialize from a 4x4 transformation matrix.
methodscipy.spatial.transform._rigid_transform.RigidTransform.from_rotation(rotation:Rotation) -> RigidTransform
Initialize from a rotation, without a translation.
methodscipy.spatial.transform._rigid_transform.RigidTransform.identity(num:int | None=None, *shape:int | tuple[int, ...] | None=None) -> RigidTransform
Initialize an identity transform.
methodscipy.spatial.transform._rigid_transform.RigidTransform.inv() -> RigidTransform
Invert this transform.
methodscipy.spatial.transform._rigid_transform.RigidTransform.mean(weights:ArrayLike | None=None, axis:None | int | tuple[int, ...]=None) -> RigidTransform
Get the mean of the transforms.
methodscipy.spatial.transform._rigid_transform.RigidTransform.rotation() -> Rotation
Return the rotation component of the transform.
methodscipy.spatial.transform._rigid_transform.RigidTransform.shape() -> tuple[int, ...]
The shape of the transform's leading dimensions.
funcscipy.spatial.transform._rigid_transform.normalize_dual_quaternion(dual_quat:ArrayLike) -> Array
Normalize dual quaternion.
funcscipy.spatial.transform._rigid_transform_xp.normalize_dual_quaternion(dual_quat:Array) -> Array
Normalize dual quaternion.
classscipy.spatial.transform._rotation.Rotation
Rotation in 3 dimensions.
methodscipy.spatial.transform._rotation.Rotation.apply(vectors:ArrayLike, inverse:bool=False) -> Array
Apply this rotation to a set of vectors.
methodscipy.spatial.transform._rotation.Rotation.as_davenport(axes:ArrayLike, order:str, degrees:bool=False, *suppress_warnings:bool=False) -> Array
Represent as Davenport angles.
methodscipy.spatial.transform._rotation.Rotation.as_euler(seq:str, degrees:bool=False, *suppress_warnings:bool=False) -> Array
Represent as Euler angles.
methodscipy.spatial.transform._rotation.Rotation.as_matrix() -> Array
Represent as rotation matrix.
methodscipy.spatial.transform._rotation.Rotation.as_mrp() -> Array
Represent as Modified Rodrigues Parameters (MRPs).
methodscipy.spatial.transform._rotation.Rotation.as_quat(canonical:bool=False, *scalar_first:bool=False) -> Array
Represent as quaternions.
methodscipy.spatial.transform._rotation.Rotation.as_rotvec(degrees:bool=False) -> Array
Represent as rotation vectors.
methodscipy.spatial.transform._rotation.Rotation.create_group(group:str, axis:str='Z') -> Rotation
Create a 3D rotation group.
methodscipy.spatial.transform._rotation.Rotation.from_davenport(axes:ArrayLike, order:str, angles:ArrayLike | float, degrees:bool=False) -> Rotation
Initialize from Davenport angles.
methodscipy.spatial.transform._rotation.Rotation.from_euler(seq:str, angles:ArrayLike, degrees:bool=False) -> Rotation
Initialize from Euler angles.
methodscipy.spatial.transform._rotation.Rotation.from_matrix(matrix:ArrayLike, *assume_valid:bool=False) -> Rotation
Initialize from rotation matrix.
methodscipy.spatial.transform._rotation.Rotation.from_mrp(mrp:ArrayLike) -> Rotation
Initialize from Modified Rodrigues Parameters (MRPs).
methodscipy.spatial.transform._rotation.Rotation.from_quat(quat:ArrayLike, *scalar_first:bool=False) -> Rotation
Initialize from quaternions.
methodscipy.spatial.transform._rotation.Rotation.from_rotvec(rotvec:ArrayLike, degrees:bool=False) -> Rotation
Initialize from rotation vectors.
methodscipy.spatial.transform._rotation.Rotation.identity(num:int | None=None, *shape:int | tuple[int, ...] | None=None) -> Rotation
Get identity rotation(s).
methodscipy.spatial.transform._rotation.Rotation.inv() -> Rotation
Invert this rotation.
methodscipy.spatial.transform._rotation.Rotation.magnitude() -> Array
Get the magnitude(s) of the rotation(s).
methodscipy.spatial.transform._rotation.Rotation.mean(weights:ArrayLike | None=None, axis:None | int | tuple[int, ...]=None) -> Rotation
Get the mean of the rotations.
methodscipy.spatial.transform._rotation.Rotation.shape() -> tuple[int, ...]
The shape of the rotation's leading dimensions.
methodscipy.spatial.transform._rotation.Rotation.single() -> bool
Whether this instance represents a single rotation.
classscipy.spatial.transform._rotation.Slerp
Spherical Linear Interpolation of Rotations.
funcscipy.spatial.transform._rotation.select_backend(xp:ModuleType, cython_compatible:bool)
Select the backend for the given array library.
funcscipy.special._basic.bernoulli(n)
Bernoulli numbers B0..Bn (inclusive).

About this data

These signatures were extracted from the public source of scipy/scipy using Python's ast module. Argument names, default values, type annotations and return types are taken verbatim from the code. Implementation bodies are never stored. See how it works for details.

Back to all 805 libraries