Directory yyy/ contains:
A file setup.py that defines
│ │ │ configuration(parent_package='',top_path=None) function
│ │ │ -for numpy.distutils.
numpy.distutils.A directory tests/ that contains files test_<name>.py
│ │ │ corresponding to modules yyy/<name>{.py,.so,/}.
Private modules should be prefixed with an underscore _,
│ │ │ for instance yyy/_somemodule.py.
User-visible functions should have good documentation following │ │ ├── ./usr/share/doc/python-scipy-doc/html/dev/contributor/contributor_toc.html │ │ │ @@ -141,30 +141,30 @@ │ │ │
Development workflow lays out what to do after your development environment is set up
SciPy Development Workflow is a five-minute video example of fixing a bug and submitting a pull request
PEP8 and SciPy gives some tips for ensuring that your code is PEP8 compliant
Git for development is a guide to using git, the distributed version-control system used to manage the changes made to SciPy code from around the world
SciPy API contains some important notes about how SciPy code is organized and documents the structure of the SciPy API; if you are going to import other SciPy code, read this first
Reviewing Pull Requests explains how to review another author’s SciPy code locally
NumPy Distutils - Users Guide - check this out before adding any new files to SciPy
NumPy Distutils - Users Guide - check this out before adding any new files to SciPy
Adding New Methods, Functions, and Classes has information on how to add new methods, functions and classes
SciPy Core Developer Guide has background information including how decisions are made and how a release is prepared; it’s geared toward Core Developers, but contains useful information for all contributors
Testing Guidelines is the definitive guide to writing unit tests of SciPy code
Testing Guidelines is the definitive guide to writing unit tests of SciPy code
Running SciPy Tests Locally documents runtests.py, a convenient script for building SciPy and running tests locally
A Guide to NumPy Documentation contains everything you need to know about writing docstrings, which are rendered to produce HTML documentation using Sphinx
Documentation style contains everything you need to know about writing docstrings, which are rendered to produce HTML documentation using Sphinx
Rendering Documentation with Sphinx it’s important to check how changes to the documentation render before merging a PR; this document explains how you can do that
Benchmarking SciPy with airspeed velocity explains how to add benchmarks to SciPy using airspeed velocity
Do all unit tests pass locally? See Running SciPy Tests Locally.
Do all public function have docstrings including examples? See the │ │ │ numpydoc docstring guide.
Does the documentation render correctly? See Rendering Documentation with Sphinx.
Is the code style correct? See PEP8 and SciPy.
Are there benchmarks? See Benchmarking SciPy with airspeed velocity.
Is the commit message formatted correctly?
Is the commit message formatted correctly?
Is the docstring of the new functionality tagged with
│ │ │ .. versionadded:: X.Y.Z (where X.Y.Z is the version number of the
│ │ │ next release? See the updating, workers, and constraints
│ │ │ documentation of differential_evolution, for example. You can get the
│ │ │ next version number from the most recent release notes on the wiki or
│ │ │ from the MAJOR and MINOR version number variables in setup.py.
In case of larger additions, is there a tutorial or more extensive │ │ ├── ./usr/share/doc/python-scipy-doc/html/dev/contributor/rendering_documentation.html │ │ │ @@ -108,15 +108,15 @@ │ │ │ │ │ │
SciPy docstrings are rendered to html using Sphinx. Writing │ │ │ -docstrings is covered in the A Guide to NumPy Documentation; this document │ │ │ +docstrings is covered in the Documentation style; this document │ │ │ explains how to check that docstrings render properly.
│ │ │For a video walkthrough, please see Rendering SciPy Documentation │ │ │ with Sphinx .
│ │ │To render the documentation on your own machine:
│ │ │gh-xxxx or #xxxx with
│ │ │ xxxx the issue/PR number. The gh-xxxx format is strongly preferred,
│ │ │ because it’s clear that that is a GitHub link. Older issues contain #xxxx
│ │ │ which is about Trac (what we used pre-GitHub) tickets.
│ │ │ PR naming convention: Pull requests, issues and commit messages usually start
│ │ │ with a three-letter abbreviation like ENH: or BUG:. This is useful to
│ │ │ quickly see what the nature of the commit/PR/issue is. For the full list of
│ │ │ -abbreviations, see writing the commit message.
SciPy is distributed under the modified (3-clause) BSD license. All code, │ │ │ documentation and other files added to SciPy by contributors is licensed under │ │ │ this license, unless another license is explicitly specified in the source │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.cluster.hierarchy.ClusterNode.pre_order.html │ │ │ @@ -104,15 +104,15 @@ │ │ │
ClusterNode.pre_order(self, func=<function ClusterNode.<lambda> at 0x7f7fc3c77dc0>)[source]¶ClusterNode.pre_order(self, func=<function ClusterNode.<lambda> at 0x7f3bd6b16670>)[source]¶
│ │ │ Perform pre-order traversal without recursive function calls.
│ │ │When a leaf node is first encountered, func is called with
│ │ │ the leaf node as its argument, and its result is appended to
│ │ │ the list.
For example, the statement:
│ │ │ids = root.pre_order(lambda x: x.id)
│ │ │ See also
│ │ │numpy.cumsum, numpy.cumprodnumpy.cumsum, numpy.cumprodquadadaptive quadrature using QUADPACK
│ │ │rombergadaptive Romberg quadrature
│ │ │quadratureadaptive Gaussian quadrature
│ │ │fixed_quadfixed-order Gaussian quadrature
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.integrate.quad_vec.html │ │ │ @@ -123,18 +123,18 @@ │ │ │Vector norm to use for error estimation.
│ │ │Number of bytes to use for memoization.
│ │ │If workers is an integer, part of the computation is done in
│ │ │ parallel subdivided to this many tasks (using
│ │ │ -multiprocessing.pool.Pool).
│ │ │ +multiprocessing.pool.Pool).
│ │ │ Supply -1 to use all cores available to the Process.
│ │ │ Alternatively, supply a map-like callable, such as
│ │ │ -multiprocessing.pool.Pool.map for evaluating the
│ │ │ +multiprocessing.pool.Pool.map for evaluating the
│ │ │ population in parallel.
│ │ │ This evaluation is carried out as workers(func, iterable).
List of additional breakpoints.
│ │ │Quadrature rule to use on subintervals. │ │ │ Options: ‘gk21’ (Gauss-Kronrod 21-point rule), │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.integrate.trapezoid.html │ │ │ @@ -130,15 +130,15 @@ │ │ │
See also
│ │ │numpy.cumsumnumpy.cumsumNotes
│ │ │Image [2] illustrates trapezoidal rule – y-axis locations of points │ │ │ will be taken from y array, by default x-axis distances between │ │ │ points will be 1.0, alternatively they can be provided with x array │ │ │ or with dx scalar. Return value will be equal to combined area under │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.interpolate.lagrange.html │ │ │ @@ -119,15 +119,15 @@ │ │ │ │ │ │
w represents the y-coordinates of a set of datapoints, i.e., f(x).
│ │ │numpy.poly1d instanceThe Lagrange interpolating polynomial.
│ │ │ +numpy.poly1d instanceThe Lagrange interpolating polynomial.
│ │ │Examples
│ │ │Interpolate \(f(x) = x^3\) by 3 points.
│ │ │>>> from scipy.interpolate import lagrange
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.io.FortranFile.html
│ │ │ @@ -135,15 +135,15 @@
│ │ │ WRITE(1) myvariable
│ │ │ Since this is a non-standard file format, whose contents depend on the │ │ │ compiler and the endianness of the machine, caution is advised. Files from │ │ │ gfortran 4.8.0 and gfortran 4.1.2 on x86_64 are known to work.
│ │ │Consider using Fortran direct-access files or files from the newer Stream
│ │ │ -I/O, which can be easily read by numpy.fromfile.
numpy.fromfile.
│ │ │ Examples
│ │ │To create an unformatted sequential Fortran file:
│ │ │>>> from scipy.io import FortranFile
│ │ │ >>> f = FortranFile('test.unf', 'w')
│ │ │ >>> f.write_record(np.array([1,2,3,4,5], dtype=np.int32))
│ │ │ >>> f.write_record(np.linspace(0,1,20).reshape((5,4)).T)
│ │ │ >>> f.close()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.io.readsav.html
│ │ │ @@ -119,15 +119,15 @@
│ │ │ case-insensitive dictionary with item, attribute, and call access
│ │ │ to variables. To get a standard Python dictionary, set this option
│ │ │ to True.
│ │ │
│ │ │ This option only has an effect for .sav files written with the
│ │ │ /compress option. If a file name is specified, compressed .sav
│ │ │ files are uncompressed to this file. Otherwise, readsav will use
│ │ │ -the tempfile module to determine a temporary filename
│ │ │ +the tempfile module to determine a temporary filename
│ │ │ automatically, and will remove the temporary file upon successfully
│ │ │ reading it in.
Whether to print out information about the save file, including │ │ │ the records read, and available variables.
│ │ │Sample rate of WAV file.
│ │ │Data read from WAV file. Data-type is determined from the file;
│ │ │ see Notes. Data is 1-D for 1-channel WAV, or 2-D of shape
│ │ │ (Nsamples, Nchannels) otherwise. If a file-like input without a
│ │ │ -C-like file descriptor (e.g., io.BytesIO) is
│ │ │ +C-like file descriptor (e.g., io.BytesIO) is
│ │ │ passed, this will not be writeable.
Notes
│ │ │Common data types: [1]
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.linalg.clarkson_woodruff_transform.html │ │ │ @@ -118,15 +118,15 @@ │ │ │Input matrix, of shape (n, d).
Number of rows for the sketch.
│ │ │numpy.random.RandomState instance, optionalThis parameter defines the RandomState object to use for drawing
│ │ │ +
numpy.random.RandomState instance, optionalThis parameter defines the RandomState object to use for drawing
│ │ │ random variates.
│ │ │ If None (or np.random), the global np.random state is used.
│ │ │ If integer, it is used to seed the local RandomState instance.
│ │ │ Default is None.
Compare multiplication by A with the use of numpy.convolve.
Compare multiplication by A with the use of numpy.convolve.
>>> x = np.array([1, 2, 0, -3, 0.5])
│ │ │ >>> A @ x
│ │ │ array([ 2. , 6. , -1. , -12.5, 8. ])
│ │ │ Verify that A @ x produced the same result as applying the
│ │ │ convolution function.
scipy.linalg.interpolative.estimate_rank(A, eps)[source]¶Estimate matrix rank to a specified relative precision using randomized │ │ │ methods.
│ │ │ -The matrix A can be given as either a numpy.ndarray or a
│ │ │ +
The matrix A can be given as either a numpy.ndarray or a
│ │ │ scipy.sparse.linalg.LinearOperator, with different algorithms used
│ │ │ -for each case. If A is of type numpy.ndarray, then the output
│ │ │ +for each case. If A is of type numpy.ndarray, then the output
│ │ │ rank is typically about 8 higher than the actual numerical rank.
numpy.ndarray or scipy.sparse.linalg.LinearOperatorMatrix whose rank is to be estimated, given as either a
│ │ │ -numpy.ndarray or a scipy.sparse.linalg.LinearOperator
│ │ │ +
numpy.ndarray or scipy.sparse.linalg.LinearOperatorMatrix whose rank is to be estimated, given as either a
│ │ │ +numpy.ndarray or a scipy.sparse.linalg.LinearOperator
│ │ │ with the rmatvec method (to apply the matrix adjoint).
Relative error for numerical rank definition.
│ │ │See also svd.
numpy.ndarraySkeleton matrix.
│ │ │ +numpy.ndarraySkeleton matrix.
│ │ │numpy.ndarrayColumn index array.
│ │ │ +numpy.ndarrayColumn index array.
│ │ │numpy.ndarrayInterpolation coefficients.
│ │ │ +numpy.ndarrayInterpolation coefficients.
│ │ │numpy.ndarrayLeft singular vectors.
│ │ │ +numpy.ndarrayLeft singular vectors.
│ │ │numpy.ndarraySingular values.
│ │ │ +numpy.ndarraySingular values.
│ │ │numpy.ndarrayRight singular vectors.
│ │ │ +numpy.ndarrayRight singular vectors.
│ │ │idx, proj = interp_decomp(A, eps_or_k)
│ │ │ numpy.ndarray or scipy.sparse.linalg.LinearOperator with rmatvecMatrix to be factored
│ │ │ +numpy.ndarray or scipy.sparse.linalg.LinearOperator with rmatvecMatrix to be factored
│ │ │Relative error (if eps_or_k < 1) or rank (if eps_or_k >= 1) of │ │ │ approximation.
│ │ │Whether to use random sampling if A is of type numpy.ndarray
│ │ │ +
Whether to use random sampling if A is of type numpy.ndarray
│ │ │ (randomized algorithms are always used if A is of type
│ │ │ scipy.sparse.linalg.LinearOperator).
Rank required to achieve specified relative precision if │ │ │ eps_or_k < 1.
│ │ │numpy.ndarrayColumn index array.
│ │ │ +numpy.ndarrayColumn index array.
│ │ │numpy.ndarrayInterpolation coefficients.
│ │ │ +numpy.ndarrayInterpolation coefficients.
│ │ │See also reconstruct_matrix_from_id and
│ │ │ reconstruct_skel_matrix.
numpy.ndarrayColumn index array.
│ │ │ +numpy.ndarrayColumn index array.
│ │ │numpy.ndarrayInterpolation coefficients.
│ │ │ +numpy.ndarrayInterpolation coefficients.
│ │ │numpy.ndarrayInterpolation matrix.
│ │ │ +numpy.ndarrayInterpolation matrix.
│ │ │See also reconstruct_interp_matrix and
│ │ │ reconstruct_skel_matrix.
numpy.ndarraySkeleton matrix.
│ │ │ +numpy.ndarraySkeleton matrix.
│ │ │numpy.ndarrayColumn index array.
│ │ │ +numpy.ndarrayColumn index array.
│ │ │numpy.ndarrayInterpolation coefficients.
│ │ │ +numpy.ndarrayInterpolation coefficients.
│ │ │numpy.ndarrayReconstructed matrix.
│ │ │ +numpy.ndarrayReconstructed matrix.
│ │ │See also reconstruct_matrix_from_id and
│ │ │ reconstruct_interp_matrix.
numpy.ndarrayOriginal matrix.
│ │ │ +numpy.ndarrayOriginal matrix.
│ │ │Rank of ID.
│ │ │numpy.ndarrayColumn index array.
│ │ │ +numpy.ndarrayColumn index array.
│ │ │numpy.ndarraySkeleton matrix.
│ │ │ +numpy.ndarraySkeleton matrix.
│ │ │If ‘default’, the random seed is reset to a default value.
│ │ │If seed is a sequence containing 55 floating-point numbers
│ │ │ in range [0,1], these are used to set the internal state of
│ │ │ the generator.
If the value is an integer, the internal state is obtained
│ │ │ -from numpy.random.RandomState (MT19937) with the integer
│ │ │ +from numpy.random.RandomState (MT19937) with the integer
│ │ │ used as the initial seed.
If seed is omitted (None), numpy.random.rand is used to
│ │ │ initialize the generator.
where U and V have orthonormal columns and S is nonnegative.
│ │ │The SVD can be computed to any relative precision or rank (depending on the │ │ │ value of eps_or_k).
│ │ │See also interp_decomp and id_to_svd.
numpy.ndarray or scipy.sparse.linalg.LinearOperatorMatrix to be factored, given as either a numpy.ndarray or a
│ │ │ +
numpy.ndarray or scipy.sparse.linalg.LinearOperatorMatrix to be factored, given as either a numpy.ndarray or a
│ │ │ scipy.sparse.linalg.LinearOperator with the matvec and
│ │ │ rmatvec methods (to apply the matrix and its adjoint).
Relative error (if eps_or_k < 1) or rank (if eps_or_k >= 1) of │ │ │ approximation.
│ │ │Whether to use random sampling if A is of type numpy.ndarray
│ │ │ +
Whether to use random sampling if A is of type numpy.ndarray
│ │ │ (randomized algorithms are always used if A is of type
│ │ │ scipy.sparse.linalg.LinearOperator).
numpy.ndarrayLeft singular vectors.
│ │ │ +numpy.ndarrayLeft singular vectors.
│ │ │numpy.ndarraySingular values.
│ │ │ +numpy.ndarraySingular values.
│ │ │numpy.ndarrayRight singular vectors.
│ │ │ +numpy.ndarrayRight singular vectors.
│ │ │Given an output image pixel index vector o, the pixel value
│ │ │ is determined from the input image at position
│ │ │ np.dot(matrix, o) + offset.
This does ‘pull’ (or ‘backward’) resampling, transforming the output space
│ │ │ to the input to locate data. Affine transformations are often described in
│ │ │ the ‘push’ (or ‘forward’) direction, transforming input to output. If you
│ │ │ have a matrix for the ‘push’ transformation, use its inverse
│ │ │ -(numpy.linalg.inv) in this function.
numpy.linalg.inv) in this function.
│ │ │ The input array.
│ │ │The inverse coordinate transformation matrix, mapping output
│ │ │ coordinates to input coordinates. If ndim is the number of
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.ndimage.generate_binary_structure.html
│ │ │ @@ -138,15 +138,15 @@
│ │ │
Notes
│ │ │generate_binary_structure can only create structuring elements with
│ │ │ dimensions equal to 3, i.e., minimal dimensions. For larger structuring
│ │ │ elements, that are useful e.g., for eroding large objects, one may either
│ │ │ use iterate_structure, or create directly custom arrays with
│ │ │ -numpy functions such as numpy.ones.
numpy.ones.
│ │ │ Examples
│ │ │>>> from scipy import ndimage
│ │ │ >>> struct = ndimage.generate_binary_structure(2, 1)
│ │ │ >>> struct
│ │ │ array([[False, True, False],
│ │ │ [ True, True, True],
│ │ │ [False, True, False]], dtype=bool)
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.ndimage.maximum.html
│ │ │ @@ -135,15 +135,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │
│ │ │ Notes
│ │ │ The function returns a Python list and not a NumPy array, use
│ │ │ np.array to convert the list to an array.
│ │ │ Examples
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.ndimage.maximum_position.html
│ │ │ @@ -140,15 +140,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │
│ │ │ Examples
│ │ │ >>> from scipy import ndimage
│ │ │ >>> a = np.array([[1, 2, 0, 0],
│ │ │ ... [5, 3, 0, 4],
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.ndimage.mean.html
│ │ │ @@ -131,15 +131,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │
│ │ │ Examples
│ │ │ >>> from scipy import ndimage
│ │ │ >>> a = np.arange(25).reshape((5,5))
│ │ │ >>> labels = np.zeros_like(a)
│ │ │ >>> labels[3:5,3:5] = 1
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.ndimage.median.html
│ │ │ @@ -135,15 +135,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │
│ │ │ Notes
│ │ │ The function returns a Python list and not a NumPy array, use
│ │ │ np.array to convert the list to an array.
│ │ │ Examples
│ │ │ >>> from scipy import ndimage
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.ndimage.minimum.html
│ │ │ @@ -135,15 +135,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │
│ │ │ Notes
│ │ │ The function returns a Python list and not a NumPy array, use
│ │ │ np.array to convert the list to an array.
│ │ │ Examples
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.ndimage.minimum_position.html
│ │ │ @@ -137,15 +137,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │
│ │ │ Examples
│ │ │ >>> a = np.array([[10, 20, 30],
│ │ │ ... [40, 80, 100],
│ │ │ ... [1, 100, 200]])
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.optimize.brute.html
│ │ │ @@ -102,15 +102,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ scipy.optimize.brute¶
│ │ │
│ │ │ -
│ │ │ -
scipy.optimize.brute(func, ranges, args=(), Ns=20, full_output=0, finish=<function fmin at 0x7f7fc9130d30>, disp=False, workers=1)[source]¶
│ │ │ +scipy.optimize.brute(func, ranges, args=(), Ns=20, full_output=0, finish=<function fmin at 0x7f3bd71788b0>, disp=False, workers=1)[source]¶
│ │ │ Minimize a function over a given range by brute force.
│ │ │ Uses the “brute force” method, i.e., computes the function’s value
│ │ │ at each point of a multidimensional grid of points, to find the global
│ │ │ minimum of the function.
│ │ │ The function is evaluated everywhere in the range with the datatype of the
│ │ │ first call to the function, as enforced by the vectorize NumPy
│ │ │ function. The value and type of the function evaluation returned when
│ │ │ @@ -152,15 +152,15 @@
│ │ │ and/or disp as keyword arguments. Use None if no “polishing”
│ │ │ function is to be used. See Notes for more details.
│ │ │ - dispbool, optional
Set to True to print convergence messages from the finish callable.
│ │ │ - workersint or map-like callable, optional
If workers is an int the grid is subdivided into workers
│ │ │ sections and evaluated in parallel (uses
│ │ │ -multiprocessing.Pool).
│ │ │ +multiprocessing.Pool).
│ │ │ Supply -1 to use all cores available to the Process.
│ │ │ Alternatively supply a map-like callable, such as
│ │ │ multiprocessing.Pool.map for evaluating the grid in parallel.
│ │ │ This evaluation is carried out as workers(func, iterable).
│ │ │ Requires that func be pickleable.
│ │ │
│ │ │ New in version 1.3.0.
│ │ │ @@ -216,15 +216,15 @@
│ │ │ Note that when finish is not None, the values returned are those
│ │ │ of the finish program, not the gridpoint ones. Consequently,
│ │ │ while brute confines its search to the input grid points,
│ │ │ the finish program’s results usually will not coincide with any
│ │ │ gridpoint, and may fall outside the grid’s boundary. Thus, if a
│ │ │ minimum only needs to be found over the provided grid points, make
│ │ │ sure to pass in finish=None.
│ │ │ -Note 2: The grid of points is a numpy.mgrid object.
│ │ │ +
Note 2: The grid of points is a numpy.mgrid object.
│ │ │ For brute the ranges and Ns inputs have the following effect.
│ │ │ Each component of the ranges tuple can be either a slice object or a
│ │ │ two-tuple giving a range of values, such as (0, 5). If the component is a
│ │ │ slice object, brute uses it directly. If the component is a two-tuple
│ │ │ range, brute internally converts it to a slice object that interpolates
│ │ │ Ns points from its low-value to its high-value, inclusive.
│ │ │ Examples
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.optimize.differential_evolution.html
│ │ │ @@ -235,15 +235,15 @@
│ │ │ the workers keyword can over-ride this option.
│ │ │
│ │ │ New in version 1.2.0.
│ │ │
│ │ │
│ │ │ - workersint or map-like callable, optional
If workers is an int the population is subdivided into workers
│ │ │ sections and evaluated in parallel
│ │ │ -(uses multiprocessing.Pool).
│ │ │ +(uses multiprocessing.Pool).
│ │ │ Supply -1 to use all available CPU cores.
│ │ │ Alternatively supply a map-like callable, such as
│ │ │ multiprocessing.Pool.map for evaluating the population in parallel.
│ │ │ This evaluation is carried out as workers(func, iterable).
│ │ │ This option will override the updating keyword to
│ │ │ updating='deferred' if workers != 1.
│ │ │ Requires that func be pickleable.
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.optimize.dual_annealing.html
│ │ │ @@ -148,15 +148,15 @@
│ │ │ a range (-1e4, -5].
│ │ │ - maxfunint, optional
Soft limit for the number of objective function calls. If the
│ │ │ algorithm is in the middle of a local search, this number will be
│ │ │ exceeded, the algorithm will stop just after the local search is
│ │ │ done. Default value is 1e7.
│ │ │ - seed{int,
RandomState, Generator}, optional If seed is not specified the RandomState singleton is
│ │ │ +
- seed{int,
RandomState, Generator}, optional If seed is not specified the RandomState singleton is
│ │ │ used.
│ │ │ If seed is an int, a new RandomState instance is used, seeded
│ │ │ with seed.
│ │ │ If seed is already a RandomState or Generator instance, then
│ │ │ that instance is used.
│ │ │ Specify seed for repeatable minimizations. The random numbers
│ │ │ generated with this seed only affect the visiting distribution function
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.optimize.lsq_linear.html
│ │ │ @@ -243,15 +243,15 @@
│ │ │
least_squaresNonlinear least squares with bounds on the variables.
│ │ │ Notes
│ │ │ The algorithm first computes the unconstrained least-squares solution by
│ │ │ -numpy.linalg.lstsq or scipy.sparse.linalg.lsmr depending on
│ │ │ +numpy.linalg.lstsq or scipy.sparse.linalg.lsmr depending on
│ │ │ lsq_solver. This solution is returned as optimal if it lies within the
│ │ │ bounds.
│ │ │ Method ‘trf’ runs the adaptation of the algorithm described in [STIR] for
│ │ │ a linear least-squares problem. The iterations are essentially the same as
│ │ │ in the nonlinear least-squares algorithm, but as the quadratic function
│ │ │ model is always accurate, we don’t need to track or modify the radius of
│ │ │ a trust region. The line search (backtracking) is used as a safety net
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.optimize.quadratic_assignment.html
│ │ │ @@ -141,15 +141,15 @@
│ │ │
Each row of partial_match specifies a pair of matched nodes:
│ │ │ node partial_match[i, 0] of A is matched to node
│ │ │ partial_match[i, 1] of B. The array has shape (m, 2),
│ │ │ where m is not greater than the number of nodes, \(n\).
│ │ │ - rngint, RandomState, Generator or None, optional (default: None)
Accepts an integer as a seed for the random generator or a
│ │ │ RandomState or Generator object. If None (default), uses
│ │ │ -global numpy.random random state.
│ │ │ +global numpy.random random state.
│ │ │
│ │ │ For method-specific options, see
│ │ │ show_options('quadratic_assignment').
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.signal.argrelextrema.html
│ │ │ @@ -119,15 +119,15 @@
│ │ │ - axisint, optional
Axis over which to select from data. Default is 0.
│ │ │ - orderint, optional
How many points on each side to use for the comparison
│ │ │ to consider comparator(n, n+x) to be True.
│ │ │ - modestr, optional
How the edges of the vector are treated. ‘wrap’ (wrap around) or
│ │ │ ‘clip’ (treat overflow as the same as the last (or first) element).
│ │ │ -Default is ‘clip’. See numpy.take.
│ │ │ +Default is ‘clip’. See numpy.take.
│ │ │ - Returns
│ │ │
│ │ │ - extrematuple of ndarrays
Indices of the maxima in arrays of integers. extrema[k] is
│ │ │ the array of indices of axis k of data. Note that the
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.signal.argrelmax.html
│ │ │ @@ -117,15 +117,15 @@
│ │ │
- orderint, optional
How many points on each side to use for the comparison
│ │ │ to consider comparator(n, n+x) to be True.
│ │ │ - modestr, optional
How the edges of the vector are treated.
│ │ │ Available options are ‘wrap’ (wrap around) or ‘clip’ (treat overflow
│ │ │ as the same as the last (or first) element).
│ │ │ -Default ‘clip’. See numpy.take.
│ │ │ +Default ‘clip’. See numpy.take.
│ │ │
│ │ │ - Returns
│ │ │
│ │ │ - extrematuple of ndarrays
Indices of the maxima in arrays of integers. extrema[k] is
│ │ │ the array of indices of axis k of data. Note that the
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.signal.convolve.html
│ │ │ @@ -156,15 +156,15 @@
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.polymulperforms polynomial multiplication (same operation, but also accepts poly1d objects)
│ │ │ +numpy.polymulperforms polynomial multiplication (same operation, but also accepts poly1d objects)
│ │ │ choose_conv_methodchooses the fastest appropriate convolution method
│ │ │ fftconvolveAlways uses the FFT method.
│ │ │ oaconvolveUses the overlap-add method to do convolution, which is generally faster when the input arrays are large and significantly different in size.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.polydivperforms polynomial division (same operation, but also accepts poly1d objects)
│ │ │ +numpy.polydivperforms polynomial division (same operation, but also accepts poly1d objects)
│ │ │
│ │ │
│ │ │ Examples
│ │ │ Deconvolve a signal that’s been filtered:
│ │ │ >>> from scipy import signal
│ │ │ >>> original = [0, 1, 0, 0, 1, 1, 0, 0]
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.signal.freqz.html
│ │ │ @@ -176,15 +176,15 @@
│ │ │ See also
│ │ │
│ │ │
│ │ │ Notes
│ │ │ -Using Matplotlib’s matplotlib.pyplot.plot function as the callable
│ │ │ +
Using Matplotlib’s matplotlib.pyplot.plot function as the callable
│ │ │ for plot produces unexpected results, as this plots the real part of the
│ │ │ complex transfer function, not the magnitude.
│ │ │ Try lambda w, h: plot(w, np.abs(h)).
│ │ │ A direct computation via (R)FFT is used to compute the frequency response
│ │ │ when the following conditions are met:
│ │ │
│ │ │ An integer value is given for worN.
nperseg==2*Zxx.shape[freq_axis] - 1, nfft also takes on
│ │ │ that value. This case allows the proper inversion of an
│ │ │ odd-length unpadded STFT using nfft=None. Defaults to
│ │ │ None.
│ │ │
│ │ │ - input_onesidedbool, optional
If True, interpret the input array as one-sided FFTs, such
│ │ │ as is returned by stft with return_onesided=True and
│ │ │ -numpy.fft.rfft. If False, interpret the input as a a
│ │ │ +numpy.fft.rfft. If False, interpret the input as a a
│ │ │ two-sided FFT. Defaults to True.
│ │ │ - boundarybool, optional
Specifies whether the input signal was extended at its
│ │ │ boundaries by supplying a non-None boundary argument to
│ │ │ stft. Defaults to True.
│ │ │ - time_axisint, optional
Where the time segments of the STFT is located; the default is
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.signal.residue.html
│ │ │ @@ -159,15 +159,15 @@
│ │ │
See also
│ │ │
│ │ │ -invres, residuez, numpy.poly, unique_rootsinvres, residuez, numpy.poly, unique_roots
│ │ │
│ │ │ Notes
│ │ │ The “deflation through subtraction” algorithm is used for
│ │ │ computations — method 6 in [1].
│ │ │ The form of partial fraction expansion depends on poles multiplicity in
│ │ │ the exact mathematical sense. However there is no way to exactly
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.signal.sweep_poly.html
│ │ │ @@ -155,15 +155,15 @@
│ │ │
│ │ │ If poly is a list or ndarray of length n, then the elements of
│ │ │ poly are the coefficients of the polynomial, and the instantaneous
│ │ │ frequency is:
│ │ │
│ │ │ f(t) = poly[0]*t**(n-1) + poly[1]*t**(n-2) + ... + poly[n-1]
│ │ │
│ │ │ -If poly is an instance of numpy.poly1d, then the instantaneous
│ │ │ +
If poly is an instance of numpy.poly1d, then the instantaneous
│ │ │ frequency is:
│ │ │
│ │ │ f(t) = poly(t)
│ │ │
│ │ │ Finally, the output s is:
│ │ │
│ │ │ cos(phase + (pi/180)*phi)
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.signal.unique_roots.html
│ │ │ @@ -144,15 +144,15 @@
│ │ │ If we have 3 roots a, b and c, such that a is close to
│ │ │ b and b is close to c (distance is less than tol), then it
│ │ │ doesn’t necessarily mean that a is close to c. It means that roots
│ │ │ grouping is not unique. In this function we use “greedy” grouping going
│ │ │ through the roots in the order they are given in the input p.
│ │ │ This utility function is not specific to roots but can be used for any
│ │ │ sequence of values for which uniqueness and multiplicity has to be
│ │ │ -determined. For a more general routine, see numpy.unique.
│ │ │ +determined. For a more general routine, see numpy.unique.
│ │ │ Examples
│ │ │ >>> from scipy import signal
│ │ │ >>> vals = [0, 1.3, 1.31, 2.8, 1.25, 2.2, 10.3]
│ │ │ >>> uniq, mult = signal.unique_roots(vals, tol=2e-2, rtype='avg')
│ │ │
│ │ │
│ │ │ Check which roots have multiplicity larger than 1:
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.signal.upfirdn.html
│ │ │ @@ -121,15 +121,15 @@
│ │ │
│ │ │ - axisint, optional
The axis of the input data array along which to apply the
│ │ │ linear filter. The filter is applied to each subarray along
│ │ │ this axis. Default is -1.
│ │ │ - modestr, optional
The signal extension mode to use. The set
│ │ │ {"constant", "symmetric", "reflect", "edge", "wrap"} correspond to
│ │ │ -modes provided by numpy.pad. "smooth" implements a smooth
│ │ │ +modes provided by numpy.pad. "smooth" implements a smooth
│ │ │ extension by extending based on the slope of the last 2 points at each
│ │ │ end of the array. "antireflect" and "antisymmetric" are
│ │ │ anti-symmetric versions of "reflect" and "symmetric". The mode
│ │ │ “line” extends the signal based on a linear trend defined by the
│ │ │ first and last points along the axis.
│ │ │
│ │ │ New in version 1.4.0.
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.arcsin.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.bsr_matrix.arcsin¶
│ │ │
│ │ │ -
│ │ │
bsr_matrix.arcsin(self)[source]¶
│ │ │ Element-wise arcsin.
│ │ │ -See numpy.arcsin for more information.
│ │ │ +See numpy.arcsin for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ scipy.sparse.bsr_matrix.arcsinh¶
│ │ │
│ │ │ -
│ │ │
bsr_matrix.arcsinh(self)[source]¶
│ │ │ Element-wise arcsinh.
│ │ │ -See numpy.arcsinh for more information.
│ │ │ +See numpy.arcsinh for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.arctan.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.bsr_matrix.arctan¶
│ │ │
│ │ │ -
│ │ │
bsr_matrix.arctan(self)[source]¶
│ │ │ Element-wise arctan.
│ │ │ -See numpy.arctan for more information.
│ │ │ +See numpy.arctan for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.arctanh.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.bsr_matrix.arctanh¶
│ │ │
│ │ │ -
│ │ │
bsr_matrix.arctanh(self)[source]¶
│ │ │ Element-wise arctanh.
│ │ │ -See numpy.arctanh for more information.
│ │ │ +See numpy.arctanh for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.ceil.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.bsr_matrix.ceil¶
│ │ │
│ │ │ -
│ │ │
bsr_matrix.ceil(self)[source]¶
│ │ │ Element-wise ceil.
│ │ │ -See numpy.ceil for more information.
│ │ │ +See numpy.ceil for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.deg2rad.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.bsr_matrix.deg2rad¶
│ │ │
│ │ │ -
│ │ │
bsr_matrix.deg2rad(self)[source]¶
│ │ │ Element-wise deg2rad.
│ │ │ -See numpy.deg2rad for more information.
│ │ │ +See numpy.deg2rad for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.diagonal.html
│ │ │ @@ -120,15 +120,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.diagonalEquivalent numpy function.
│ │ │ +numpy.diagonalEquivalent numpy function.
│ │ │
│ │ │
│ │ │ Examples
│ │ │ >>> from scipy.sparse import csr_matrix
│ │ │ >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
│ │ │ >>> A.diagonal()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.expm1.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.bsr_matrix.expm1¶
│ │ │
│ │ │ -
│ │ │
bsr_matrix.expm1(self)[source]¶
│ │ │ Element-wise expm1.
│ │ │ -See numpy.expm1 for more information.
│ │ │ +See numpy.expm1 for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.floor.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.bsr_matrix.floor¶
│ │ │
│ │ │ -
│ │ │
bsr_matrix.floor(self)[source]¶
│ │ │ Element-wise floor.
│ │ │ -See numpy.floor for more information.
│ │ │ +See numpy.floor for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.getH.html
│ │ │ @@ -108,15 +108,15 @@
│ │ │ bsr_matrix.getH(self)[source]¶Return the Hermitian transpose of this matrix.
│ │ │See also
│ │ │numpy.matrix.getHNumPy’s implementation of getH for matrices
numpy.matrix.getHNumPy’s implementation of getH for matrices
bsr_matrix.log1p(self)[source]¶Element-wise log1p.
│ │ │ -See numpy.log1p for more information.
See numpy.log1p for more information.
See also
│ │ │minThe minimum value of a sparse matrix along a given axis.
│ │ │numpy.matrix.maxNumPy’s implementation of ‘max’ for matrices
│ │ │ +numpy.matrix.maxNumPy’s implementation of ‘max’ for matrices
│ │ │See also
│ │ │numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │ +numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │See also
│ │ │maxThe maximum value of a sparse matrix along a given axis.
│ │ │numpy.matrix.minNumPy’s implementation of ‘min’ for matrices
│ │ │ +numpy.matrix.minNumPy’s implementation of ‘min’ for matrices
│ │ │bsr_matrix.rad2deg(self)[source]¶Element-wise rad2deg.
│ │ │ -See numpy.rad2deg for more information.
See numpy.rad2deg for more information.
See also
│ │ │numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │ +numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │number of rows and columns in the new matrix
│ │ │Notes
│ │ │ -The semantics are not identical to numpy.ndarray.resize or
│ │ │ -numpy.resize. Here, the same data will be maintained at each index
│ │ │ +
The semantics are not identical to numpy.ndarray.resize or
│ │ │ +numpy.resize. Here, the same data will be maintained at each index
│ │ │ before and after reshape, if that index is within the new bounds. In
│ │ │ numpy, resizing maintains contiguity of the array, moving elements
│ │ │ around in the logical matrix but not within a flattened representation.
We give no guarantees about whether the underlying data attributes │ │ │ (arrays, etc.) will be modified in place or replaced with new objects.
│ │ │ │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.bsr_matrix.rint.html │ │ │ @@ -105,15 +105,15 @@ │ │ │ │ │ │bsr_matrix.rint(self)[source]¶Element-wise rint.
│ │ │ -See numpy.rint for more information.
See numpy.rint for more information.
bsr_matrix.sign(self)[source]¶Element-wise sign.
│ │ │ -See numpy.sign for more information.
See numpy.sign for more information.
bsr_matrix.sinh(self)[source]¶Element-wise sinh.
│ │ │ -See numpy.sinh for more information.
See numpy.sinh for more information.
bsr_matrix.sqrt(self)[source]¶Element-wise sqrt.
│ │ │ -See numpy.sqrt for more information.
See numpy.sqrt for more information.
See also
│ │ │numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │ +numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │bsr_matrix.tanh(self)[source]¶Element-wise tanh.
│ │ │ -See numpy.tanh for more information.
See numpy.tanh for more information.
Whether to store multi-dimensional data in C (row-major) │ │ │ or Fortran (column-major) order in memory. The default │ │ │ is ‘None’, indicating the NumPy default of C-ordered. │ │ │ Cannot be specified in conjunction with the out │ │ │ argument.
│ │ │If specified, uses this array (or numpy.matrix) as the
│ │ │ +
If specified, uses this array (or numpy.matrix) as the
│ │ │ output buffer instead of allocating a new array to
│ │ │ return. The provided array must have the same shape and
│ │ │ dtype as the sparse matrix on which you are calling the
│ │ │ method.
A NumPy matrix object with the same shape and containing
│ │ │ the same data represented by the sparse matrix, with the
│ │ │ requested memory order. If out was passed and was an
│ │ │ -array (rather than a numpy.matrix), it will be filled
│ │ │ +array (rather than a numpy.matrix), it will be filled
│ │ │ with the appropriate values and returned wrapped in a
│ │ │ -numpy.matrix object that shares the same memory.
numpy.matrix object that shares the same memory.
│ │ │ See also
│ │ │numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │ +numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │bsr_matrix.trunc(self)[source]¶Element-wise trunc.
│ │ │ -See numpy.trunc for more information.
See numpy.trunc for more information.
coo_matrix.arcsin(self)[source]¶Element-wise arcsin.
│ │ │ -See numpy.arcsin for more information.
See numpy.arcsin for more information.
coo_matrix.arcsinh(self)[source]¶Element-wise arcsinh.
│ │ │ -See numpy.arcsinh for more information.
See numpy.arcsinh for more information.
coo_matrix.arctan(self)[source]¶Element-wise arctan.
│ │ │ -See numpy.arctan for more information.
See numpy.arctan for more information.
coo_matrix.arctanh(self)[source]¶Element-wise arctanh.
│ │ │ -See numpy.arctanh for more information.
See numpy.arctanh for more information.
coo_matrix.ceil(self)[source]¶Element-wise ceil.
│ │ │ -See numpy.ceil for more information.
See numpy.ceil for more information.
coo_matrix.deg2rad(self)[source]¶Element-wise deg2rad.
│ │ │ -See numpy.deg2rad for more information.
See numpy.deg2rad for more information.
See also
│ │ │numpy.diagonalEquivalent numpy function.
│ │ │ +numpy.diagonalEquivalent numpy function.
│ │ │Examples
│ │ │>>> from scipy.sparse import csr_matrix
│ │ │ >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
│ │ │ >>> A.diagonal()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.coo_matrix.expm1.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.coo_matrix.expm1¶
│ │ │
│ │ │ -
│ │ │
coo_matrix.expm1(self)[source]¶
│ │ │ Element-wise expm1.
│ │ │ -See numpy.expm1 for more information.
│ │ │ +See numpy.expm1 for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ coo_matrix.floor(self)[source]¶Element-wise floor.
│ │ │ -See numpy.floor for more information.
See numpy.floor for more information.
coo_matrix.getH(self)[source]¶Return the Hermitian transpose of this matrix.
│ │ │See also
│ │ │numpy.matrix.getHNumPy’s implementation of getH for matrices
numpy.matrix.getHNumPy’s implementation of getH for matrices
coo_matrix.log1p(self)[source]¶Element-wise log1p.
│ │ │ -See numpy.log1p for more information.
See numpy.log1p for more information.
See also
│ │ │minThe minimum value of a sparse matrix along a given axis.
│ │ │numpy.matrix.maxNumPy’s implementation of ‘max’ for matrices
│ │ │ +numpy.matrix.maxNumPy’s implementation of ‘max’ for matrices
│ │ │See also
│ │ │numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │ +numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │See also
│ │ │maxThe maximum value of a sparse matrix along a given axis.
│ │ │numpy.matrix.minNumPy’s implementation of ‘min’ for matrices
│ │ │ +numpy.matrix.minNumPy’s implementation of ‘min’ for matrices
│ │ │coo_matrix.rad2deg(self)[source]¶Element-wise rad2deg.
│ │ │ -See numpy.rad2deg for more information.
See numpy.rad2deg for more information.
See also
│ │ │numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │ +numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │number of rows and columns in the new matrix
│ │ │Notes
│ │ │ -The semantics are not identical to numpy.ndarray.resize or
│ │ │ -numpy.resize. Here, the same data will be maintained at each index
│ │ │ +
The semantics are not identical to numpy.ndarray.resize or
│ │ │ +numpy.resize. Here, the same data will be maintained at each index
│ │ │ before and after reshape, if that index is within the new bounds. In
│ │ │ numpy, resizing maintains contiguity of the array, moving elements
│ │ │ around in the logical matrix but not within a flattened representation.
We give no guarantees about whether the underlying data attributes │ │ │ (arrays, etc.) will be modified in place or replaced with new objects.
│ │ │ │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.coo_matrix.rint.html │ │ │ @@ -105,15 +105,15 @@ │ │ │ │ │ │coo_matrix.rint(self)[source]¶Element-wise rint.
│ │ │ -See numpy.rint for more information.
See numpy.rint for more information.
coo_matrix.sign(self)[source]¶Element-wise sign.
│ │ │ -See numpy.sign for more information.
See numpy.sign for more information.
coo_matrix.sinh(self)[source]¶Element-wise sinh.
│ │ │ -See numpy.sinh for more information.
See numpy.sinh for more information.
coo_matrix.sqrt(self)[source]¶Element-wise sqrt.
│ │ │ -See numpy.sqrt for more information.
See numpy.sqrt for more information.
See also
│ │ │numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │ +numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │coo_matrix.tanh(self)[source]¶Element-wise tanh.
│ │ │ -See numpy.tanh for more information.
See numpy.tanh for more information.
Whether to store multi-dimensional data in C (row-major) │ │ │ or Fortran (column-major) order in memory. The default │ │ │ is ‘None’, indicating the NumPy default of C-ordered. │ │ │ Cannot be specified in conjunction with the out │ │ │ argument.
│ │ │If specified, uses this array (or numpy.matrix) as the
│ │ │ +
If specified, uses this array (or numpy.matrix) as the
│ │ │ output buffer instead of allocating a new array to
│ │ │ return. The provided array must have the same shape and
│ │ │ dtype as the sparse matrix on which you are calling the
│ │ │ method.
A NumPy matrix object with the same shape and containing
│ │ │ the same data represented by the sparse matrix, with the
│ │ │ requested memory order. If out was passed and was an
│ │ │ -array (rather than a numpy.matrix), it will be filled
│ │ │ +array (rather than a numpy.matrix), it will be filled
│ │ │ with the appropriate values and returned wrapped in a
│ │ │ -numpy.matrix object that shares the same memory.
numpy.matrix object that shares the same memory.
│ │ │ See also
│ │ │numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │ +numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │coo_matrix.trunc(self)[source]¶Element-wise trunc.
│ │ │ -See numpy.trunc for more information.
See numpy.trunc for more information.
csc_matrix.arcsin(self)[source]¶Element-wise arcsin.
│ │ │ -See numpy.arcsin for more information.
See numpy.arcsin for more information.
csc_matrix.arcsinh(self)[source]¶Element-wise arcsinh.
│ │ │ -See numpy.arcsinh for more information.
See numpy.arcsinh for more information.
csc_matrix.arctan(self)[source]¶Element-wise arctan.
│ │ │ -See numpy.arctan for more information.
See numpy.arctan for more information.
csc_matrix.arctanh(self)[source]¶Element-wise arctanh.
│ │ │ -See numpy.arctanh for more information.
See numpy.arctanh for more information.
csc_matrix.ceil(self)[source]¶Element-wise ceil.
│ │ │ -See numpy.ceil for more information.
See numpy.ceil for more information.
csc_matrix.deg2rad(self)[source]¶Element-wise deg2rad.
│ │ │ -See numpy.deg2rad for more information.
See numpy.deg2rad for more information.
See also
│ │ │numpy.diagonalEquivalent numpy function.
│ │ │ +numpy.diagonalEquivalent numpy function.
│ │ │Examples
│ │ │>>> from scipy.sparse import csr_matrix
│ │ │ >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
│ │ │ >>> A.diagonal()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.csc_matrix.expm1.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.csc_matrix.expm1¶
│ │ │
│ │ │ -
│ │ │
csc_matrix.expm1(self)[source]¶
│ │ │ Element-wise expm1.
│ │ │ -See numpy.expm1 for more information.
│ │ │ +See numpy.expm1 for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ csc_matrix.floor(self)[source]¶Element-wise floor.
│ │ │ -See numpy.floor for more information.
See numpy.floor for more information.
csc_matrix.getH(self)[source]¶Return the Hermitian transpose of this matrix.
│ │ │See also
│ │ │numpy.matrix.getHNumPy’s implementation of getH for matrices
numpy.matrix.getHNumPy’s implementation of getH for matrices
csc_matrix.log1p(self)[source]¶Element-wise log1p.
│ │ │ -See numpy.log1p for more information.
See numpy.log1p for more information.
See also
│ │ │minThe minimum value of a sparse matrix along a given axis.
│ │ │numpy.matrix.maxNumPy’s implementation of ‘max’ for matrices
│ │ │ +numpy.matrix.maxNumPy’s implementation of ‘max’ for matrices
│ │ │See also
│ │ │numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │ +numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │See also
│ │ │maxThe maximum value of a sparse matrix along a given axis.
│ │ │numpy.matrix.minNumPy’s implementation of ‘min’ for matrices
│ │ │ +numpy.matrix.minNumPy’s implementation of ‘min’ for matrices
│ │ │csc_matrix.rad2deg(self)[source]¶Element-wise rad2deg.
│ │ │ -See numpy.rad2deg for more information.
See numpy.rad2deg for more information.
See also
│ │ │numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │ +numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │number of rows and columns in the new matrix
│ │ │Notes
│ │ │ -The semantics are not identical to numpy.ndarray.resize or
│ │ │ -numpy.resize. Here, the same data will be maintained at each index
│ │ │ +
The semantics are not identical to numpy.ndarray.resize or
│ │ │ +numpy.resize. Here, the same data will be maintained at each index
│ │ │ before and after reshape, if that index is within the new bounds. In
│ │ │ numpy, resizing maintains contiguity of the array, moving elements
│ │ │ around in the logical matrix but not within a flattened representation.
We give no guarantees about whether the underlying data attributes │ │ │ (arrays, etc.) will be modified in place or replaced with new objects.
│ │ │ │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.csc_matrix.rint.html │ │ │ @@ -105,15 +105,15 @@ │ │ │ │ │ │csc_matrix.rint(self)[source]¶Element-wise rint.
│ │ │ -See numpy.rint for more information.
See numpy.rint for more information.
csc_matrix.sign(self)[source]¶Element-wise sign.
│ │ │ -See numpy.sign for more information.
See numpy.sign for more information.
csc_matrix.sinh(self)[source]¶Element-wise sinh.
│ │ │ -See numpy.sinh for more information.
See numpy.sinh for more information.
csc_matrix.sqrt(self)[source]¶Element-wise sqrt.
│ │ │ -See numpy.sqrt for more information.
See numpy.sqrt for more information.
See also
│ │ │numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │ +numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │csc_matrix.tanh(self)[source]¶Element-wise tanh.
│ │ │ -See numpy.tanh for more information.
See numpy.tanh for more information.
Whether to store multi-dimensional data in C (row-major) │ │ │ or Fortran (column-major) order in memory. The default │ │ │ is ‘None’, indicating the NumPy default of C-ordered. │ │ │ Cannot be specified in conjunction with the out │ │ │ argument.
│ │ │If specified, uses this array (or numpy.matrix) as the
│ │ │ +
If specified, uses this array (or numpy.matrix) as the
│ │ │ output buffer instead of allocating a new array to
│ │ │ return. The provided array must have the same shape and
│ │ │ dtype as the sparse matrix on which you are calling the
│ │ │ method.
A NumPy matrix object with the same shape and containing
│ │ │ the same data represented by the sparse matrix, with the
│ │ │ requested memory order. If out was passed and was an
│ │ │ -array (rather than a numpy.matrix), it will be filled
│ │ │ +array (rather than a numpy.matrix), it will be filled
│ │ │ with the appropriate values and returned wrapped in a
│ │ │ -numpy.matrix object that shares the same memory.
numpy.matrix object that shares the same memory.
│ │ │ See also
│ │ │numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │ +numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │csc_matrix.trunc(self)[source]¶Element-wise trunc.
│ │ │ -See numpy.trunc for more information.
See numpy.trunc for more information.
csr_matrix.arcsin(self)[source]¶Element-wise arcsin.
│ │ │ -See numpy.arcsin for more information.
See numpy.arcsin for more information.
csr_matrix.arcsinh(self)[source]¶Element-wise arcsinh.
│ │ │ -See numpy.arcsinh for more information.
See numpy.arcsinh for more information.
csr_matrix.arctan(self)[source]¶Element-wise arctan.
│ │ │ -See numpy.arctan for more information.
See numpy.arctan for more information.
csr_matrix.arctanh(self)[source]¶Element-wise arctanh.
│ │ │ -See numpy.arctanh for more information.
See numpy.arctanh for more information.
csr_matrix.ceil(self)[source]¶Element-wise ceil.
│ │ │ -See numpy.ceil for more information.
See numpy.ceil for more information.
csr_matrix.deg2rad(self)[source]¶Element-wise deg2rad.
│ │ │ -See numpy.deg2rad for more information.
See numpy.deg2rad for more information.
See also
│ │ │numpy.diagonalEquivalent numpy function.
│ │ │ +numpy.diagonalEquivalent numpy function.
│ │ │Examples
│ │ │>>> from scipy.sparse import csr_matrix
│ │ │ >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
│ │ │ >>> A.diagonal()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.csr_matrix.expm1.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.csr_matrix.expm1¶
│ │ │
│ │ │ -
│ │ │
csr_matrix.expm1(self)[source]¶
│ │ │ Element-wise expm1.
│ │ │ -See numpy.expm1 for more information.
│ │ │ +See numpy.expm1 for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ csr_matrix.floor(self)[source]¶Element-wise floor.
│ │ │ -See numpy.floor for more information.
See numpy.floor for more information.
csr_matrix.getH(self)[source]¶Return the Hermitian transpose of this matrix.
│ │ │See also
│ │ │numpy.matrix.getHNumPy’s implementation of getH for matrices
numpy.matrix.getHNumPy’s implementation of getH for matrices
csr_matrix.log1p(self)[source]¶Element-wise log1p.
│ │ │ -See numpy.log1p for more information.
See numpy.log1p for more information.
See also
│ │ │minThe minimum value of a sparse matrix along a given axis.
│ │ │numpy.matrix.maxNumPy’s implementation of ‘max’ for matrices
│ │ │ +numpy.matrix.maxNumPy’s implementation of ‘max’ for matrices
│ │ │See also
│ │ │numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │ +numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │See also
│ │ │maxThe maximum value of a sparse matrix along a given axis.
│ │ │numpy.matrix.minNumPy’s implementation of ‘min’ for matrices
│ │ │ +numpy.matrix.minNumPy’s implementation of ‘min’ for matrices
│ │ │csr_matrix.rad2deg(self)[source]¶Element-wise rad2deg.
│ │ │ -See numpy.rad2deg for more information.
See numpy.rad2deg for more information.
See also
│ │ │numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │ +numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │number of rows and columns in the new matrix
│ │ │Notes
│ │ │ -The semantics are not identical to numpy.ndarray.resize or
│ │ │ -numpy.resize. Here, the same data will be maintained at each index
│ │ │ +
The semantics are not identical to numpy.ndarray.resize or
│ │ │ +numpy.resize. Here, the same data will be maintained at each index
│ │ │ before and after reshape, if that index is within the new bounds. In
│ │ │ numpy, resizing maintains contiguity of the array, moving elements
│ │ │ around in the logical matrix but not within a flattened representation.
We give no guarantees about whether the underlying data attributes │ │ │ (arrays, etc.) will be modified in place or replaced with new objects.
│ │ │ │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.csr_matrix.rint.html │ │ │ @@ -105,15 +105,15 @@ │ │ │ │ │ │csr_matrix.rint(self)[source]¶Element-wise rint.
│ │ │ -See numpy.rint for more information.
See numpy.rint for more information.
csr_matrix.sign(self)[source]¶Element-wise sign.
│ │ │ -See numpy.sign for more information.
See numpy.sign for more information.
csr_matrix.sinh(self)[source]¶Element-wise sinh.
│ │ │ -See numpy.sinh for more information.
See numpy.sinh for more information.
csr_matrix.sqrt(self)[source]¶Element-wise sqrt.
│ │ │ -See numpy.sqrt for more information.
See numpy.sqrt for more information.
See also
│ │ │numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │ +numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │csr_matrix.tanh(self)[source]¶Element-wise tanh.
│ │ │ -See numpy.tanh for more information.
See numpy.tanh for more information.
Whether to store multi-dimensional data in C (row-major) │ │ │ or Fortran (column-major) order in memory. The default │ │ │ is ‘None’, indicating the NumPy default of C-ordered. │ │ │ Cannot be specified in conjunction with the out │ │ │ argument.
│ │ │If specified, uses this array (or numpy.matrix) as the
│ │ │ +
If specified, uses this array (or numpy.matrix) as the
│ │ │ output buffer instead of allocating a new array to
│ │ │ return. The provided array must have the same shape and
│ │ │ dtype as the sparse matrix on which you are calling the
│ │ │ method.
A NumPy matrix object with the same shape and containing
│ │ │ the same data represented by the sparse matrix, with the
│ │ │ requested memory order. If out was passed and was an
│ │ │ -array (rather than a numpy.matrix), it will be filled
│ │ │ +array (rather than a numpy.matrix), it will be filled
│ │ │ with the appropriate values and returned wrapped in a
│ │ │ -numpy.matrix object that shares the same memory.
numpy.matrix object that shares the same memory.
│ │ │ See also
│ │ │numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │ +numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │csr_matrix.trunc(self)[source]¶Element-wise trunc.
│ │ │ -See numpy.trunc for more information.
See numpy.trunc for more information.
dia_matrix.arcsin(self)[source]¶Element-wise arcsin.
│ │ │ -See numpy.arcsin for more information.
See numpy.arcsin for more information.
dia_matrix.arcsinh(self)[source]¶Element-wise arcsinh.
│ │ │ -See numpy.arcsinh for more information.
See numpy.arcsinh for more information.
dia_matrix.arctan(self)[source]¶Element-wise arctan.
│ │ │ -See numpy.arctan for more information.
See numpy.arctan for more information.
dia_matrix.arctanh(self)[source]¶Element-wise arctanh.
│ │ │ -See numpy.arctanh for more information.
See numpy.arctanh for more information.
dia_matrix.ceil(self)[source]¶Element-wise ceil.
│ │ │ -See numpy.ceil for more information.
See numpy.ceil for more information.
dia_matrix.deg2rad(self)[source]¶Element-wise deg2rad.
│ │ │ -See numpy.deg2rad for more information.
See numpy.deg2rad for more information.
See also
│ │ │numpy.diagonalEquivalent numpy function.
│ │ │ +numpy.diagonalEquivalent numpy function.
│ │ │Examples
│ │ │>>> from scipy.sparse import csr_matrix
│ │ │ >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
│ │ │ >>> A.diagonal()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.dia_matrix.expm1.html
│ │ │ @@ -105,15 +105,15 @@
│ │ │
│ │ │
│ │ │ scipy.sparse.dia_matrix.expm1¶
│ │ │
│ │ │ -
│ │ │
dia_matrix.expm1(self)[source]¶
│ │ │ Element-wise expm1.
│ │ │ -See numpy.expm1 for more information.
│ │ │ +See numpy.expm1 for more information.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ dia_matrix.floor(self)[source]¶Element-wise floor.
│ │ │ -See numpy.floor for more information.
See numpy.floor for more information.
dia_matrix.getH(self)[source]¶Return the Hermitian transpose of this matrix.
│ │ │See also
│ │ │numpy.matrix.getHNumPy’s implementation of getH for matrices
numpy.matrix.getHNumPy’s implementation of getH for matrices
dia_matrix.log1p(self)[source]¶Element-wise log1p.
│ │ │ -See numpy.log1p for more information.
See numpy.log1p for more information.
See also
│ │ │numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │ +numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │dia_matrix.rad2deg(self)[source]¶Element-wise rad2deg.
│ │ │ -See numpy.rad2deg for more information.
See numpy.rad2deg for more information.
See also
│ │ │numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │ +numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │number of rows and columns in the new matrix
│ │ │Notes
│ │ │ -The semantics are not identical to numpy.ndarray.resize or
│ │ │ -numpy.resize. Here, the same data will be maintained at each index
│ │ │ +
The semantics are not identical to numpy.ndarray.resize or
│ │ │ +numpy.resize. Here, the same data will be maintained at each index
│ │ │ before and after reshape, if that index is within the new bounds. In
│ │ │ numpy, resizing maintains contiguity of the array, moving elements
│ │ │ around in the logical matrix but not within a flattened representation.
We give no guarantees about whether the underlying data attributes │ │ │ (arrays, etc.) will be modified in place or replaced with new objects.
│ │ │ │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.dia_matrix.rint.html │ │ │ @@ -105,15 +105,15 @@ │ │ │ │ │ │dia_matrix.rint(self)[source]¶Element-wise rint.
│ │ │ -See numpy.rint for more information.
See numpy.rint for more information.
dia_matrix.sign(self)[source]¶Element-wise sign.
│ │ │ -See numpy.sign for more information.
See numpy.sign for more information.
dia_matrix.sinh(self)[source]¶Element-wise sinh.
│ │ │ -See numpy.sinh for more information.
See numpy.sinh for more information.
dia_matrix.sqrt(self)[source]¶Element-wise sqrt.
│ │ │ -See numpy.sqrt for more information.
See numpy.sqrt for more information.
See also
│ │ │numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │ +numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │dia_matrix.tanh(self)[source]¶Element-wise tanh.
│ │ │ -See numpy.tanh for more information.
See numpy.tanh for more information.
Whether to store multi-dimensional data in C (row-major) │ │ │ or Fortran (column-major) order in memory. The default │ │ │ is ‘None’, indicating the NumPy default of C-ordered. │ │ │ Cannot be specified in conjunction with the out │ │ │ argument.
│ │ │If specified, uses this array (or numpy.matrix) as the
│ │ │ +
If specified, uses this array (or numpy.matrix) as the
│ │ │ output buffer instead of allocating a new array to
│ │ │ return. The provided array must have the same shape and
│ │ │ dtype as the sparse matrix on which you are calling the
│ │ │ method.
A NumPy matrix object with the same shape and containing
│ │ │ the same data represented by the sparse matrix, with the
│ │ │ requested memory order. If out was passed and was an
│ │ │ -array (rather than a numpy.matrix), it will be filled
│ │ │ +array (rather than a numpy.matrix), it will be filled
│ │ │ with the appropriate values and returned wrapped in a
│ │ │ -numpy.matrix object that shares the same memory.
numpy.matrix object that shares the same memory.
│ │ │ See also
│ │ │numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │ +numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │dia_matrix.trunc(self)[source]¶Element-wise trunc.
│ │ │ -See numpy.trunc for more information.
See numpy.trunc for more information.
>>> diags([1, -2, 1], [-1, 0, 1], shape=(4, 4)).toarray()
│ │ │ array([[-2., 1., 0., 0.],
│ │ │ [ 1., -2., 1., 0.],
│ │ │ [ 0., 1., -2., 1.],
│ │ │ [ 0., 0., 1., -2.]])
│ │ │ If only one diagonal is wanted (as in numpy.diag), the following
│ │ │ +
If only one diagonal is wanted (as in numpy.diag), the following
│ │ │ works as well:
>>> diags([1, 2, 3], 1).toarray()
│ │ │ array([[ 0., 1., 0., 0.],
│ │ │ [ 0., 0., 2., 0.],
│ │ │ [ 0., 0., 0., 3.],
│ │ │ [ 0., 0., 0., 0.]])
│ │ │ See also
│ │ │numpy.diagonalEquivalent numpy function.
│ │ │ +numpy.diagonalEquivalent numpy function.
│ │ │Examples
│ │ │>>> from scipy.sparse import csr_matrix
│ │ │ >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
│ │ │ >>> A.diagonal()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.dok_matrix.getH.html
│ │ │ @@ -108,15 +108,15 @@
│ │ │ dok_matrix.getH(self)[source]¶Return the Hermitian transpose of this matrix.
│ │ │See also
│ │ │numpy.matrix.getHNumPy’s implementation of getH for matrices
numpy.matrix.getHNumPy’s implementation of getH for matrices
See also
│ │ │numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │ +numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │See also
│ │ │numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │ +numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │number of rows and columns in the new matrix
│ │ │Notes
│ │ │ -The semantics are not identical to numpy.ndarray.resize or
│ │ │ -numpy.resize. Here, the same data will be maintained at each index
│ │ │ +
The semantics are not identical to numpy.ndarray.resize or
│ │ │ +numpy.resize. Here, the same data will be maintained at each index
│ │ │ before and after reshape, if that index is within the new bounds. In
│ │ │ numpy, resizing maintains contiguity of the array, moving elements
│ │ │ around in the logical matrix but not within a flattened representation.
We give no guarantees about whether the underlying data attributes │ │ │ (arrays, etc.) will be modified in place or replaced with new objects.
│ │ │ │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.dok_matrix.sum.html │ │ │ @@ -142,15 +142,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │See also
│ │ │numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │ +numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │Whether to store multi-dimensional data in C (row-major) │ │ │ or Fortran (column-major) order in memory. The default │ │ │ is ‘None’, indicating the NumPy default of C-ordered. │ │ │ Cannot be specified in conjunction with the out │ │ │ argument.
│ │ │If specified, uses this array (or numpy.matrix) as the
│ │ │ +
If specified, uses this array (or numpy.matrix) as the
│ │ │ output buffer instead of allocating a new array to
│ │ │ return. The provided array must have the same shape and
│ │ │ dtype as the sparse matrix on which you are calling the
│ │ │ method.
A NumPy matrix object with the same shape and containing
│ │ │ the same data represented by the sparse matrix, with the
│ │ │ requested memory order. If out was passed and was an
│ │ │ -array (rather than a numpy.matrix), it will be filled
│ │ │ +array (rather than a numpy.matrix), it will be filled
│ │ │ with the appropriate values and returned wrapped in a
│ │ │ -numpy.matrix object that shares the same memory.
numpy.matrix object that shares the same memory.
│ │ │ See also
│ │ │numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │ +numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │See also
│ │ │numpy.diagonalEquivalent numpy function.
│ │ │ +numpy.diagonalEquivalent numpy function.
│ │ │Examples
│ │ │>>> from scipy.sparse import csr_matrix
│ │ │ >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
│ │ │ >>> A.diagonal()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.lil_matrix.getH.html
│ │ │ @@ -108,15 +108,15 @@
│ │ │ lil_matrix.getH(self)[source]¶Return the Hermitian transpose of this matrix.
│ │ │See also
│ │ │numpy.matrix.getHNumPy’s implementation of getH for matrices
numpy.matrix.getHNumPy’s implementation of getH for matrices
See also
│ │ │numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │ +numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │See also
│ │ │numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │ +numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │number of rows and columns in the new matrix
│ │ │Notes
│ │ │ -The semantics are not identical to numpy.ndarray.resize or
│ │ │ -numpy.resize. Here, the same data will be maintained at each index
│ │ │ +
The semantics are not identical to numpy.ndarray.resize or
│ │ │ +numpy.resize. Here, the same data will be maintained at each index
│ │ │ before and after reshape, if that index is within the new bounds. In
│ │ │ numpy, resizing maintains contiguity of the array, moving elements
│ │ │ around in the logical matrix but not within a flattened representation.
We give no guarantees about whether the underlying data attributes │ │ │ (arrays, etc.) will be modified in place or replaced with new objects.
│ │ │ │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.lil_matrix.sum.html │ │ │ @@ -142,15 +142,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │See also
│ │ │numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │ +numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │Whether to store multi-dimensional data in C (row-major) │ │ │ or Fortran (column-major) order in memory. The default │ │ │ is ‘None’, indicating the NumPy default of C-ordered. │ │ │ Cannot be specified in conjunction with the out │ │ │ argument.
│ │ │If specified, uses this array (or numpy.matrix) as the
│ │ │ +
If specified, uses this array (or numpy.matrix) as the
│ │ │ output buffer instead of allocating a new array to
│ │ │ return. The provided array must have the same shape and
│ │ │ dtype as the sparse matrix on which you are calling the
│ │ │ method.
A NumPy matrix object with the same shape and containing
│ │ │ the same data represented by the sparse matrix, with the
│ │ │ requested memory order. If out was passed and was an
│ │ │ -array (rather than a numpy.matrix), it will be filled
│ │ │ +array (rather than a numpy.matrix), it will be filled
│ │ │ with the appropriate values and returned wrapped in a
│ │ │ -numpy.matrix object that shares the same memory.
numpy.matrix object that shares the same memory.
│ │ │ See also
│ │ │numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │ +numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │The result of the action \(e^{t_k A} B\).
│ │ │Notes
│ │ │The optional arguments defining the sequence of evenly spaced time points
│ │ │ -are compatible with the arguments of numpy.linspace.
numpy.linspace.
│ │ │ The output ndarray shape is somewhat complicated so I explain it here. │ │ │ The ndim of the output could be either 1, 2, or 3. │ │ │ It would be 1 if you are computing the expm action on a single vector │ │ │ at a single time point. │ │ │ It would be 2 if you are computing the expm action on a vector │ │ │ at multiple time points, or if you are computing the expm action │ │ │ on a matrix at a single time point. │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.load_npz.html │ │ │ @@ -130,15 +130,15 @@ │ │ │ │ │ │ │ │ │
See also
│ │ │scipy.sparse.save_npzSave a sparse matrix to a file using .npz format.
numpy.loadLoad several arrays from a .npz archive.
numpy.loadLoad several arrays from a .npz archive.
Examples
│ │ │Store sparse matrix to disk, and load it again:
│ │ │>>> import scipy.sparse
│ │ │ >>> sparse_matrix = scipy.sparse.csc_matrix(np.array([[0, 0, 3], [4, 0, 0]]))
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.save_npz.html
│ │ │ @@ -124,17 +124,17 @@
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ scipy.sparse.load_npzLoad a sparse matrix from a file using .npz format.
│ │ │ numpy.savezSave several arrays into a .npz archive.
│ │ │ +numpy.savezSave several arrays into a .npz archive.
│ │ │ numpy.savez_compressedSave several arrays into a compressed .npz archive.
│ │ │ +numpy.savez_compressedSave several arrays into a compressed .npz archive.
│ │ │
│ │ │
│ │ │ Examples
│ │ │ Store sparse matrix to disk, and load it again:
│ │ │ >>> import scipy.sparse
│ │ │ >>> sparse_matrix = scipy.sparse.csc_matrix(np.array([[0, 0, 3], [4, 0, 0]]))
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.spmatrix.diagonal.html
│ │ │ @@ -120,15 +120,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.diagonalEquivalent numpy function.
│ │ │ +numpy.diagonalEquivalent numpy function.
│ │ │
│ │ │
│ │ │ Examples
│ │ │ >>> from scipy.sparse import csr_matrix
│ │ │ >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
│ │ │ >>> A.diagonal()
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.spmatrix.getH.html
│ │ │ @@ -108,15 +108,15 @@
│ │ │
│ │ │ -
│ │ │
spmatrix.getH(self)[source]¶
│ │ │ Return the Hermitian transpose of this matrix.
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.matrix.getHNumPy’s implementation of getH for matrices
│ │ │ +numpy.matrix.getHNumPy’s implementation of getH for matrices
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.spmatrix.mean.html
│ │ │ @@ -140,15 +140,15 @@
│ │ │ mnp.matrix
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │ +numpy.matrix.meanNumPy’s implementation of ‘mean’ for matrices
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.spmatrix.reshape.html
│ │ │ @@ -133,15 +133,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │ +numpy.matrix.reshapeNumPy’s implementation of ‘reshape’ for matrices
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.spmatrix.resize.html
│ │ │ @@ -117,16 +117,16 @@
│ │ │
│ │ │ - shape(int, int)
number of rows and columns in the new matrix
│ │ │
│ │ │ Notes
│ │ │ -The semantics are not identical to numpy.ndarray.resize or
│ │ │ -numpy.resize. Here, the same data will be maintained at each index
│ │ │ +
The semantics are not identical to numpy.ndarray.resize or
│ │ │ +numpy.resize. Here, the same data will be maintained at each index
│ │ │ before and after reshape, if that index is within the new bounds. In
│ │ │ numpy, resizing maintains contiguity of the array, moving elements
│ │ │ around in the logical matrix but not within a flattened representation.
│ │ │ We give no guarantees about whether the underlying data attributes
│ │ │ (arrays, etc.) will be modified in place or replaced with new objects.
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.spmatrix.sum.html
│ │ │ @@ -142,15 +142,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │ +numpy.matrix.sumNumPy’s implementation of ‘sum’ for matrices
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.sparse.spmatrix.todense.html
│ │ │ @@ -114,30 +114,30 @@
│ │ │ Whether to store multi-dimensional data in C (row-major) │ │ │ or Fortran (column-major) order in memory. The default │ │ │ is ‘None’, indicating the NumPy default of C-ordered. │ │ │ Cannot be specified in conjunction with the out │ │ │ argument.
│ │ │If specified, uses this array (or numpy.matrix) as the
│ │ │ +
If specified, uses this array (or numpy.matrix) as the
│ │ │ output buffer instead of allocating a new array to
│ │ │ return. The provided array must have the same shape and
│ │ │ dtype as the sparse matrix on which you are calling the
│ │ │ method.
A NumPy matrix object with the same shape and containing
│ │ │ the same data represented by the sparse matrix, with the
│ │ │ requested memory order. If out was passed and was an
│ │ │ -array (rather than a numpy.matrix), it will be filled
│ │ │ +array (rather than a numpy.matrix), it will be filled
│ │ │ with the appropriate values and returned wrapped in a
│ │ │ -numpy.matrix object that shares the same memory.
numpy.matrix object that shares the same memory.
│ │ │ See also
│ │ │numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │ +numpy.matrix.transposeNumPy’s implementation of ‘transpose’ for matrices
│ │ │See also
│ │ │Delaunaymatplotlib.pyplot.triplotmatplotlib.pyplot.triplotNotes
│ │ │Requires Matplotlib.
│ │ │Examples
│ │ │>>> import matplotlib.pyplot as plt
│ │ │ >>> from scipy.spatial import Delaunay, delaunay_plot_2d
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.spatial.distance.directed_hausdorff.html
│ │ │ @@ -113,15 +113,15 @@
│ │ │ Input array.
│ │ │Input array.
│ │ │Local numpy.random.RandomState seed. Default is 0, a random
│ │ │ +
Local numpy.random.RandomState seed. Default is 0, a random
│ │ │ shuffling of u and v that guarantees reproducibility.
The directed Hausdorff distance between arrays u and v,
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.spatial.transform.Rotation.as_quat.html │ │ │ @@ -94,15 +94,15 @@ │ │ │ quaternions [1]. The mapping from quaternions to rotations is │ │ │ two-to-one, i.e. quaternionsq and -q, where -q simply
│ │ │ reverses the sign of each component, represent the same spatial
│ │ │ rotation. The returned value is in scalar-last (x, y, z, w) format.
│ │ │ numpy.ndarray, shape (4,) or (N, 4)Shape depends on shape of inputs used for initialization.
│ │ │ +numpy.ndarray, shape (4,) or (N, 4)Shape depends on shape of inputs used for initialization.
│ │ │References
│ │ │Number of random rotations to generate. If None (default), then a │ │ │ single rotation is generated.
│ │ │Accepts an integer as a seed for the random generator or a
│ │ │ -RandomState object. If None (default), uses global numpy.random
│ │ │ +RandomState object. If None (default), uses global numpy.random
│ │ │ random state.
Rotation instanceContains a single rotation if num is None. Otherwise contains a │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.diric.html │ │ │ @@ -164,15 +164,15 @@ │ │ │
>>> np.abs(np.fft.fft(x))
│ │ │ array([ 3. , 2.41421356, 1. , 0.41421356, 1. ,
│ │ │ 0.41421356, 1. , 2.41421356])
│ │ │ Now find the same values (up to sign) using diric. We multiply
│ │ │ by k to account for the different scaling conventions of
│ │ │ -numpy.fft.fft and diric:
numpy.fft.fft and diric:
│ │ │ >>> theta = np.linspace(0, 2*np.pi, m, endpoint=False)
│ │ │ >>> k * special.diric(theta, k)
│ │ │ array([ 3. , 2.41421356, 1. , -0.41421356, -1. ,
│ │ │ -0.41421356, 1. , 2.41421356])
│ │ │ See also
│ │ │geterrget the current way of handling special-function errors
│ │ │seterrset how special-function errors are handled
│ │ │numpy.errstatesimilar numpy function for floating-point errors
│ │ │ +numpy.errstatesimilar numpy function for floating-point errors
│ │ │Examples
│ │ │>>> import scipy.special as sc
│ │ │ >>> from pytest import raises
│ │ │ >>> sc.gammaln(0)
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.eval_chebyc.html
│ │ │ @@ -134,15 +134,15 @@
│ │ │
│ │ │ See also
│ │ │
│ │ │ roots_chebycroots and quadrature weights of Chebyshev polynomials of the first kind on [-2, 2]
│ │ │ chebycChebyshev polynomial object
│ │ │ numpy.polynomial.chebyshev.ChebyshevChebyshev series
│ │ │ +numpy.polynomial.chebyshev.ChebyshevChebyshev series
│ │ │ eval_chebytevaluate Chebycshev polynomials of the first kind
│ │ │
│ │ │
│ │ │ References
│ │ │ chebyuChebychev polynomial object
│ │ │eval_chebyuevaluate Chebyshev polynomials of the second kind
│ │ │hyp2f1Gauss hypergeometric function
│ │ │numpy.polynomial.chebyshev.ChebyshevChebyshev series
│ │ │ +numpy.polynomial.chebyshev.ChebyshevChebyshev series
│ │ │Notes
│ │ │This routine is numerically stable for x in [-1, 1] at least
│ │ │ up to order 10000.
References
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.eval_hermite.html │ │ │ @@ -132,15 +132,15 @@ │ │ │See also
│ │ │roots_hermiteroots and quadrature weights of physicist’s Hermite polynomials
│ │ │hermitephysicist’s Hermite polynomial object
│ │ │numpy.polynomial.hermite.HermitePhysicist’s Hermite series
│ │ │ +numpy.polynomial.hermite.HermitePhysicist’s Hermite series
│ │ │eval_hermitenormevaluate Probabilist’s Hermite polynomials
│ │ │References
│ │ │See also
│ │ │roots_hermitenormroots and quadrature weights of probabilist’s Hermite polynomials
│ │ │hermitenormprobabilist’s Hermite polynomial object
│ │ │numpy.polynomial.hermite_e.HermiteEProbabilist’s Hermite series
│ │ │ +numpy.polynomial.hermite_e.HermiteEProbabilist’s Hermite series
│ │ │eval_hermiteevaluate physicist’s Hermite polynomials
│ │ │References
│ │ │See also
│ │ │roots_laguerreroots and quadrature weights of Laguerre polynomials
│ │ │laguerreLaguerre polynomial object
│ │ │numpy.polynomial.laguerre.LaguerreLaguerre series
│ │ │ +numpy.polynomial.laguerre.LaguerreLaguerre series
│ │ │eval_genlaguerreevaluate generalized Laguerre polynomials
│ │ │References
│ │ │roots_legendreroots and quadrature weights of Legendre polynomials
│ │ │legendreLegendre polynomial object
│ │ │hyp2f1Gauss hypergeometric function
│ │ │numpy.polynomial.legendre.LegendreLegendre series
│ │ │ +numpy.polynomial.legendre.LegendreLegendre series
│ │ │References
│ │ │Milton Abramowitz and Irene A. Stegun, eds. │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.eval_sh_chebyt.html │ │ │ @@ -136,15 +136,15 @@ │ │ │
roots_sh_chebytroots and quadrature weights of shifted Chebyshev polynomials of the first kind
│ │ │sh_chebytshifted Chebyshev polynomial object
│ │ │eval_chebytevaluate Chebyshev polynomials of the first kind
│ │ │numpy.polynomial.chebyshev.ChebyshevChebyshev series
│ │ │ +numpy.polynomial.chebyshev.ChebyshevChebyshev series
│ │ │References
│ │ │Milton Abramowitz and Irene A. Stegun, eds. │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.eval_sh_legendre.html │ │ │ @@ -135,15 +135,15 @@ │ │ │
roots_sh_legendreroots and quadrature weights of shifted Legendre polynomials
│ │ │sh_legendreshifted Legendre polynomial object
│ │ │eval_legendreevaluate Legendre polynomials
│ │ │numpy.polynomial.legendre.LegendreLegendre series
│ │ │ +numpy.polynomial.legendre.LegendreLegendre series
│ │ │References
│ │ │Milton Abramowitz and Irene A. Stegun, eds. │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.gammaln.html │ │ │ @@ -136,15 +136,15 @@ │ │ │
loggammaprincipal branch of the logarithm of the gamma function
│ │ │Notes
│ │ │It is the same function as the Python standard library function
│ │ │ -math.lgamma.
math.lgamma.
│ │ │ When used in conjunction with gammasgn, this function is useful
│ │ │ for working in logspace on the real axis without having to deal
│ │ │ with complex numbers via the relation exp(gammaln(x)) =
│ │ │ gammasgn(x) * gamma(x).
For complex-valued log-gamma, use loggamma instead of gammaln.
References
│ │ │See also
│ │ │seterrset how special-function errors are handled
│ │ │errstatecontext manager for special-function error handling
│ │ │numpy.geterrsimilar numpy function for floating-point errors
│ │ │ +numpy.geterrsimilar numpy function for floating-point errors
│ │ │Notes
│ │ │For complete documentation of the types of special-function errors
│ │ │ and treatment options, see seterr.
Examples
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.logsumexp.html │ │ │ @@ -154,15 +154,15 @@ │ │ │ │ │ │See also
│ │ │numpy.logaddexp, numpy.logaddexp2numpy.logaddexp, numpy.logaddexp2Notes
│ │ │NumPy has a logaddexp function which is very similar to logsumexp, but
│ │ │ only handles two arguments. logaddexp.reduce is similar to this
│ │ │ function, but may be less stable.
Examples
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.roots_chebyt.html │ │ │ @@ -136,15 +136,15 @@ │ │ │ │ │ │ │ │ │See also
│ │ │scipy.integrate.quadraturescipy.integrate.fixed_quadnumpy.polynomial.chebyshev.chebgaussnumpy.polynomial.chebyshev.chebgaussReferences
│ │ │Milton Abramowitz and Irene A. Stegun, eds. │ │ │ Handbook of Mathematical Functions with Formulas, │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.roots_hermite.html │ │ │ @@ -136,15 +136,15 @@ │ │ │
See also
│ │ │scipy.integrate.quadraturescipy.integrate.fixed_quadnumpy.polynomial.hermite.hermgaussnumpy.polynomial.hermite.hermgaussroots_hermitenormNotes
│ │ │For small n up to 150 a modified version of the Golub-Welsch │ │ │ algorithm is used. Nodes are computed from the eigenvalue │ │ │ problem and improved by one step of a Newton iteration. │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.roots_hermitenorm.html │ │ │ @@ -136,15 +136,15 @@ │ │ │ │ │ │ │ │ │
See also
│ │ │scipy.integrate.quadraturescipy.integrate.fixed_quadnumpy.polynomial.hermite_e.hermegaussnumpy.polynomial.hermite_e.hermegaussNotes
│ │ │For small n up to 150 a modified version of the Golub-Welsch │ │ │ algorithm is used. Nodes are computed from the eigenvalue │ │ │ problem and improved by one step of a Newton iteration. │ │ │ The weights are computed from the well-known analytical formula.
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.roots_laguerre.html │ │ │ @@ -135,15 +135,15 @@ │ │ │ │ │ │ │ │ │See also
│ │ │scipy.integrate.quadraturescipy.integrate.fixed_quadnumpy.polynomial.laguerre.laggaussnumpy.polynomial.laguerre.laggaussReferences
│ │ │Milton Abramowitz and Irene A. Stegun, eds. │ │ │ Handbook of Mathematical Functions with Formulas, │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.roots_legendre.html │ │ │ @@ -135,15 +135,15 @@ │ │ │
See also
│ │ │scipy.integrate.quadraturescipy.integrate.fixed_quadnumpy.polynomial.legendre.leggaussnumpy.polynomial.legendre.leggaussReferences
│ │ │Milton Abramowitz and Irene A. Stegun, eds. │ │ │ Handbook of Mathematical Functions with Formulas, │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.special.seterr.html │ │ │ @@ -112,15 +112,15 @@ │ │ │
Set treatment for all type of special-function errors at │ │ │ once. The options are:
│ │ │‘ignore’ Take no action when the error occurs
‘warn’ Print a SpecialFunctionWarning when the error
│ │ │ -occurs (via the Python warnings module)
warnings module)‘raise’ Raise a SpecialFunctionError when the error
│ │ │ occurs.
The default is to not change the current behavior. If
│ │ │ behaviors for additional categories of special-function errors
│ │ │ are specified, then all is applied first, followed by the
│ │ │ additional categories.
See also
│ │ │geterrget the current way of handling special-function errors
│ │ │errstatecontext manager for special-function error handling
│ │ │numpy.seterrsimilar numpy function for floating-point errors
│ │ │ +numpy.seterrsimilar numpy function for floating-point errors
│ │ │Examples
│ │ │>>> import scipy.special as sc
│ │ │ >>> from pytest import raises
│ │ │ >>> sc.gammaln(0)
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.binned_statistic.html
│ │ │ @@ -174,15 +174,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │
│ │ │ Notes
│ │ │ All but the last (righthand-most) bin is half-open. In other words, if
│ │ │ bins is [1, 2, 3, 4], then the first bin is [1, 2) (including 1,
│ │ │ but excluding 2) and the second [2, 3). The last bin, however, is
│ │ │ [3, 4], which includes 4.
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.binned_statistic_2d.html
│ │ │ @@ -193,15 +193,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.digitize, numpy.histogram2d, binned_statistic, binned_statistic_ddnumpy.digitize, numpy.histogram2d, binned_statistic, binned_statistic_dd
│ │ │
│ │ │ Notes
│ │ │ Binedges:
│ │ │ All but the last (righthand-most) bin is half-open. In other words, if
│ │ │ bins is [1, 2, 3, 4], then the first bin is [1, 2) (including 1,
│ │ │ but excluding 2) and the second [2, 3). The last bin, however, is
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.binned_statistic_dd.html
│ │ │ @@ -195,15 +195,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.digitize, numpy.histogramdd, binned_statistic, binned_statistic_2dnumpy.digitize, numpy.histogramdd, binned_statistic, binned_statistic_2d
│ │ │
│ │ │ Notes
│ │ │ Binedges:
│ │ │ All but the last (righthand-most) bin is half-open in each dimension. In
│ │ │ other words, if bins is [1, 2, 3, 4], then the first bin is
│ │ │ [1, 2) (including 1, but excluding 2) and the second [2, 3). The
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.boxcox_normplot.html
│ │ │ @@ -118,15 +118,15 @@
│ │ │
│ │ │
The lower and upper bounds for the lmbda values to pass to boxcox
│ │ │ for Box-Cox transformations. These are also the limits of the
│ │ │ horizontal axis of the plot if that is generated.
If given, plots the quantiles and least squares fit.
│ │ │ plot is an object that has to have methods “plot” and “text”.
│ │ │ -The matplotlib.pyplot module or a Matplotlib Axes object can be used,
│ │ │ +The matplotlib.pyplot module or a Matplotlib Axes object can be used,
│ │ │ or a custom object with the same methods.
│ │ │ Default is None, which means that no plot is created.
Number of points on the horizontal axis (equally distributed from │ │ │ la to lb).
│ │ │An exponentiated Weibull continuous random variable.
│ │ │As an instance of the rv_continuous class, exponweib object inherits from it
│ │ │ a collection of generic methods (see below for the full list),
│ │ │ and completes them with details specific for this particular distribution.
See also
│ │ │weibull_min, numpy.random.RandomState.weibullweibull_min, numpy.random.RandomState.weibullNotes
│ │ │The probability density function for exponweib is:
and its cumulative distribution function is:
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.find_repeats.html │ │ │ @@ -121,15 +121,15 @@ │ │ │Number of times the corresponding ‘value’ is repeated.
│ │ │Notes
│ │ │ -In numpy >= 1.9 numpy.unique provides similar functionality. The main
│ │ │ +
In numpy >= 1.9 numpy.unique provides similar functionality. The main
│ │ │ difference is that find_repeats only returns repeated values.
Examples
│ │ │>>> from scipy import stats
│ │ │ >>> stats.find_repeats([2, 1, 2, 3, 2, 2, 5])
│ │ │ RepeatedResults(values=array([2.]), counts=array([4]))
│ │ │ See also
│ │ │numpy.meanArithmetic average
│ │ │ +numpy.meanArithmetic average
│ │ │numpy.averageWeighted average
│ │ │ +numpy.averageWeighted average
│ │ │hmeanHarmonic mean
│ │ │Notes
│ │ │The geometric average is computed over a single dimension of the input │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.hmean.html │ │ │ @@ -131,17 +131,17 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
See also
│ │ │numpy.meanArithmetic average
│ │ │ +numpy.meanArithmetic average
│ │ │numpy.averageWeighted average
│ │ │ +numpy.averageWeighted average
│ │ │gmeanGeometric mean
│ │ │Notes
│ │ │The harmonic mean is computed over a single dimension of the input │ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.iqr.html │ │ │ @@ -110,15 +110,15 @@ │ │ │
Compute the interquartile range of the data along the specified axis.
│ │ │The interquartile range (IQR) is the difference between the 75th and │ │ │ 25th percentile of the data. It is a measure of the dispersion │ │ │ similar to standard deviation or variance, but is much more robust │ │ │ against outliers [2].
│ │ │The rng parameter allows this function to compute other
│ │ │ percentile ranges than the actual IQR. For example, setting
│ │ │ -rng=(0, 100) is equivalent to numpy.ptp.
rng=(0, 100) is equivalent to numpy.ptp.
│ │ │ The IQR of an empty array is np.nan.
│ │ │New in version 0.18.0.
│ │ │Notes
│ │ │ -This function is heavily dependent on the version of numpy that is
│ │ │ +
This function is heavily dependent on the version of numpy that is
│ │ │ installed. Versions greater than 1.11.0b3 are highly recommended, as they
│ │ │ -include a number of enhancements and fixes to numpy.percentile and
│ │ │ -numpy.nanpercentile that affect the operation of this function. The
│ │ │ +include a number of enhancements and fixes to numpy.percentile and
│ │ │ +numpy.nanpercentile that affect the operation of this function. The
│ │ │ following modifications apply:
The default behavior of numpy.percentile is used for ‘propagate’. This
│ │ │ +
The default behavior of numpy.percentile is used for ‘propagate’. This
│ │ │ is a hybrid of ‘omit’ and ‘propagate’ that mostly yields a skewed
│ │ │ version of ‘omit’ since NaNs are sorted to the end of the data. A
│ │ │ warning is raised if there are NaNs in the data.
numpy.nanpercentile does not exist.This means that numpy.percentile is used regardless of nan_policy
│ │ │ +
numpy.nanpercentile does not exist.This means that numpy.percentile is used regardless of nan_policy
│ │ │ and a warning is issued. See previous item for a description of the
│ │ │ behavior.
The keywords get ignored with a warning if supplied with non-default │ │ │ values. However, multiple axes are still supported.
│ │ │scipy.stats.median_abs_deviation(x, axis=0, center=<function median at 0x7f7fcc8150d0>, scale=1.0, nan_policy='propagate')[source]¶scipy.stats.median_abs_deviation(x, axis=0, center=<function median at 0x7f3bde9ee0d0>, scale=1.0, nan_policy='propagate')[source]¶
│ │ │ Compute the median absolute deviation of the data along the given axis.
│ │ │The median absolute deviation (MAD, [1]) computes the median over the │ │ │ absolute deviations from the median. It is a measure of dispersion │ │ │ similar to the standard deviation but more robust to outliers [2].
│ │ │The MAD of an empty array is np.nan.
New in version 1.5.0.
│ │ │ @@ -155,15 +155,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │See also
│ │ │numpy.std, numpy.var, numpy.median, scipy.stats.iqr, scipy.stats.tmeannumpy.std, numpy.var, numpy.median, scipy.stats.iqr, scipy.stats.tmeanscipy.stats.tstd, scipy.stats.tvarNotes
│ │ │The center argument only affects the calculation of the central value
│ │ │ around which the MAD is calculated. That is, passing in center=np.mean
│ │ │ will calculate the MAD around the mean - it will not calculate the mean
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.median_absolute_deviation.html
│ │ │ @@ -156,15 +156,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
See also
│ │ │numpy.std, numpy.var, numpy.median, scipy.stats.iqr, scipy.stats.tmeannumpy.std, numpy.var, numpy.median, scipy.stats.iqr, scipy.stats.tmeanscipy.stats.tstd, scipy.stats.tvarNotes
│ │ │The center argument only affects the calculation of the central value
│ │ │ around which the MAD is calculated. That is, passing in center=np.mean
│ │ │ will calculate the MAD around the mean - it will not calculate the mean
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.mstats.argstoarray.html
│ │ │ @@ -123,15 +123,15 @@
│ │ │
A ( m x n ) masked array, where m is the number of arguments and │ │ │ n the length of the longest argument.
│ │ │Notes
│ │ │ -numpy.ma.row_stack has identical behavior, but is called with a sequence
│ │ │ +
numpy.ma.row_stack has identical behavior, but is called with a sequence
│ │ │ of sequences.
Examples
│ │ │A 2D masked array constructed from a group of sequences is returned.
│ │ │>>> from scipy.stats.mstats import argstoarray
│ │ │ >>> argstoarray([1, 2, 3], [4, 5, 6])
│ │ │ masked_array(
│ │ │ data=[[1.0, 2.0, 3.0],
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.mstats.gmean.html
│ │ │ @@ -133,17 +133,17 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.meanArithmetic average
│ │ │ +numpy.meanArithmetic average
│ │ │ numpy.averageWeighted average
│ │ │ +numpy.averageWeighted average
│ │ │ hmeanHarmonic mean
│ │ │
│ │ │
│ │ │ Notes
│ │ │ The geometric average is computed over a single dimension of the input
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.mstats.hmean.html
│ │ │ @@ -132,17 +132,17 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.meanArithmetic average
│ │ │ +numpy.meanArithmetic average
│ │ │ numpy.averageWeighted average
│ │ │ +numpy.averageWeighted average
│ │ │ gmeanGeometric mean
│ │ │
│ │ │
│ │ │ Notes
│ │ │ The harmonic mean is computed over a single dimension of the input
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.multinomial.html
│ │ │ @@ -129,15 +129,15 @@
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ scipy.stats.binomThe binomial distribution.
│ │ │ numpy.random.Generator.multinomialSampling from the multinomial distribution.
│ │ │ +numpy.random.Generator.multinomialSampling from the multinomial distribution.
│ │ │ scipy.stats.multivariate_hypergeomThe multivariate hypergeometric distribution.
│ │ │
│ │ │
│ │ │ Notes
│ │ │ n should be a positive integer. Each element of p should be in the
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.multiscale_graphcorr.html
│ │ │ @@ -102,15 +102,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ scipy.stats.multiscale_graphcorr¶
│ │ │
│ │ │ -
│ │ │ -
scipy.stats.multiscale_graphcorr(x, y, compute_distance=<function _euclidean_dist at 0x7f7fc87a8700>, reps=1000, workers=1, is_twosamp=False, random_state=None)[source]¶
│ │ │ +scipy.stats.multiscale_graphcorr(x, y, compute_distance=<function _euclidean_dist at 0x7f3bd5f6f430>, reps=1000, workers=1, is_twosamp=False, random_state=None)[source]¶
│ │ │ Computes the Multiscale Graph Correlation (MGC) test statistic.
│ │ │ Specifically, for each point, MGC finds the \(k\)-nearest neighbors for
│ │ │ one property (e.g. cloud density), and the \(l\)-nearest neighbors for
│ │ │ the other property (e.g. grass wetness) [1]. This pair \((k, l)\) is
│ │ │ called the “scale”. A priori, however, it is not know which scales will be
│ │ │ most informative. So, MGC computes all distance pairs, and then efficiently
│ │ │ computes the distance correlations for all scales. The local correlations
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.percentileofscore.html
│ │ │ @@ -142,15 +142,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ See also
│ │ │
│ │ │ -numpy.percentilenumpy.percentile
│ │ │
│ │ │ Examples
│ │ │ Three-quarters of the given values lie below a given score:
│ │ │ >>> from scipy import stats
│ │ │ >>> stats.percentileofscore([1, 2, 3, 4], 3)
│ │ │ 75.0
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.power_divergence.html
│ │ │ @@ -149,15 +149,15 @@
│ │ │
│ │ │
- Returns
│ │ │
│ │ │ - statisticfloat or ndarray
The Cressie-Read power divergence test statistic. The value is
│ │ │ a float if axis is None or if` f_obs and f_exp are 1-D.
│ │ │ - pvaluefloat or ndarray
The p-value of the test. The value is a float if ddof and the
│ │ │ -return value stat are scalars.
│ │ │ +return value stat are scalars.
│ │ │
│ │ │ See also
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.ppcc_plot.html
│ │ │ @@ -125,15 +125,15 @@
│ │ │
│ │ │ - diststr or stats.distributions instance, optional
Distribution or distribution function name. Objects that look enough
│ │ │ like a stats.distributions instance (i.e. they have a ppf method)
│ │ │ are also accepted. The default is 'tukeylambda'.
│ │ │ - plotobject, optional
If given, plots PPCC against the shape parameter.
│ │ │ plot is an object that has to have methods “plot” and “text”.
│ │ │ -The matplotlib.pyplot module or a Matplotlib Axes object can be used,
│ │ │ +The matplotlib.pyplot module or a Matplotlib Axes object can be used,
│ │ │ or a custom object with the same methods.
│ │ │ Default is None, which means that no plot is created.
│ │ │ - Nint, optional
Number of points on the horizontal axis (equally distributed from
│ │ │ a to b).
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.probplot.html
│ │ │ @@ -126,15 +126,15 @@
│ │ │ accepted.
│ │ │
│ │ │ - fitbool, optional
Fit a least-squares regression (best-fit) line to the sample data if
│ │ │ True (default).
│ │ │ - plotobject, optional
If given, plots the quantiles and least squares fit.
│ │ │ plot is an object that has to have methods “plot” and “text”.
│ │ │ -The matplotlib.pyplot module or a Matplotlib Axes object can be used,
│ │ │ +The matplotlib.pyplot module or a Matplotlib Axes object can be used,
│ │ │ or a custom object with the same methods.
│ │ │ Default is None, which means that no plot is created.
│ │ │ - Returns
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.scoreatpercentile.html
│ │ │ @@ -147,22 +147,22 @@
│ │ │
See also
│ │ │
│ │ │ -percentileofscore, numpy.percentilepercentileofscore, numpy.percentile
│ │ │
│ │ │ Notes
│ │ │ This function will become obsolete in the future.
│ │ │ -For NumPy 1.9 and higher, numpy.percentile provides all the functionality
│ │ │ +For NumPy 1.9 and higher, numpy.percentile provides all the functionality
│ │ │ that scoreatpercentile provides. And it’s significantly faster.
│ │ │ -Therefore it’s recommended to use numpy.percentile for users that have
│ │ │ +Therefore it’s recommended to use numpy.percentile for users that have
│ │ │ numpy >= 1.9.
│ │ │ Examples
│ │ │ >>> from scipy import stats
│ │ │ >>> a = np.arange(100)
│ │ │ >>> stats.scoreatpercentile(a, 50)
│ │ │ 49.5
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.weibull_min.html
│ │ │ @@ -114,15 +114,15 @@
│ │ │ minimum of iid random variables.
│ │ │ As an instance of the rv_continuous class, weibull_min object inherits from it
│ │ │ a collection of generic methods (see below for the full list),
│ │ │ and completes them with details specific for this particular distribution.
│ │ │
│ │ │ See also
│ │ │
│ │ │ -weibull_max, numpy.random.RandomState.weibull, exponweibweibull_max, numpy.random.RandomState.weibull, exponweib
│ │ │
│ │ │ Notes
│ │ │ The probability density function for weibull_min is:
│ │ │
│ │ │ \[f(x, c) = c x^{c-1} \exp(-x^c)\]
│ │ │ for \(x > 0\), \(c > 0\).
│ │ ├── ./usr/share/doc/python-scipy-doc/html/generated/scipy.stats.yeojohnson_normplot.html
│ │ │ @@ -118,15 +118,15 @@
│ │ │
│ │ │ - la, lbscalar
The lower and upper bounds for the lmbda values to pass to
│ │ │ yeojohnson for Yeo-Johnson transformations. These are also the
│ │ │ limits of the horizontal axis of the plot if that is generated.
│ │ │ - plotobject, optional
If given, plots the quantiles and least squares fit.
│ │ │ plot is an object that has to have methods “plot” and “text”.
│ │ │ -The matplotlib.pyplot module or a Matplotlib Axes object can be used,
│ │ │ +The matplotlib.pyplot module or a Matplotlib Axes object can be used,
│ │ │ or a custom object with the same methods.
│ │ │ Default is None, which means that no plot is created.
│ │ │ - Nint, optional
Number of points on the horizontal axis (equally distributed from
│ │ │ la to lb).
│ │ │
│ │ │
│ │ │ - Unit tests
In principle you should aim to create unit tests that exercise all the code
│ │ │ that you are adding. This gives some degree of confidence that your code
│ │ │ runs correctly, also on Python versions and hardware or OSes that you don’t
│ │ │ have available yourself. An extensive description of how to write unit
│ │ │ -tests is given in Testing Guidelines, and Running SciPy Tests Locally
│ │ │ +tests is given in Testing Guidelines, and Running SciPy Tests Locally
│ │ │ documents how to run them.
│ │ │
│ │ │
│ │ │ - Benchmarks
Unit tests check for correct functionality; benchmarks measure code
│ │ │ performance. Not all existing SciPy code has benchmarks, but it should:
│ │ │ @@ -186,15 +186,15 @@
│ │ │ to find and understand the code. Documentation for individual functions
│ │ │ and classes – which includes at least a basic description, type and
│ │ │ meaning of all parameters and returns values, and usage examples in
│ │ │ doctest format – is put in docstrings. Those docstrings can be read
│ │ │ within the interpreter, and are compiled into a reference guide in html and
│ │ │ pdf format. Higher-level documentation for key (areas of) functionality is
│ │ │ provided in tutorial format and/or in module docstrings. A guide on how to
│ │ │ -write documentation is given in A Guide to NumPy Documentation, and
│ │ │ +write documentation is given in Documentation style, and
│ │ │ Rendering Documentation with Sphinx explains how to preview the documentation
│ │ │ as it will appear online.
│ │ │
│ │ │
│ │ │ - Code style
Uniformity of style in which code is written is important to others trying
│ │ ├── ./usr/share/doc/python-scipy-doc/html/linalg.interpolative.html
│ │ │ @@ -282,15 +282,15 @@
│ │ │ >>> n = 1000
│ │ │ >>> A = np.empty((n, n), order='F')
│ │ │ >>> for j in range(n):
│ │ │ >>> for i in range(m):
│ │ │ >>> A[i,j] = 1. / (i + j + 1)
│ │ │
│ │ │
│ │ │ -Note the use of the flag order='F' in numpy.empty. This
│ │ │ +
Note the use of the flag order='F' in numpy.empty. This
│ │ │ instantiates the matrix in Fortran-contiguous order and is important for
│ │ │ avoiding data copying when passing to the backend.
│ │ │ We then define multiplication routines for the matrix by regarding it as a
│ │ │ scipy.sparse.linalg.LinearOperator:
│ │ │ >>> from scipy.sparse.linalg import aslinearoperator
│ │ │ >>> L = aslinearoperator(A)
│ │ │
│ │ │ @@ -431,15 +431,15 @@
│ │ │ >>> snorm = sli.estimate_spectral_norm(A)
│ │ │
│ │ │
│ │ │ This algorithm is based on the randomized power method and thus requires only
│ │ │ matrix-vector products. The number of iterations to take can be set using the
│ │ │ keyword its (default: its=20). The matrix is interpreted as a
│ │ │ scipy.sparse.linalg.LinearOperator, but it is also valid to supply it
│ │ │ -as a numpy.ndarray, in which case it is trivially converted using
│ │ │ +as a numpy.ndarray, in which case it is trivially converted using
│ │ │ scipy.sparse.linalg.aslinearoperator.
│ │ │ The same algorithm can also estimate the spectral norm of the difference of two
│ │ │ matrices A1 and A2 as follows:
│ │ │ >>> diff = sli.estimate_spectral_norm_diff(A1, A2)
│ │ │
│ │ │
│ │ │ This is often useful for checking the accuracy of a matrix approximation.
│ │ ├── ./usr/share/doc/python-scipy-doc/html/optimize.qap-2opt.html
│ │ │ @@ -159,15 +159,15 @@
│ │ │
│ │ │ - Options
│ │ │
│ │ │ - maximizebool (default: False)
Maximizes the objective function if True.
│ │ │ - rngint, RandomState, Generator or None, optional (default: None)
Accepts an integer as a seed for the random generator or a
│ │ │ RandomState or Generator object. If None (default), uses
│ │ │ -global numpy.random random state.
│ │ │ +global numpy.random random state.
│ │ │ - partial_match2-D array of integers, optional (default: None)
Fixes part of the matching. Also known as a “seed” [2].
│ │ │ Each row of partial_match specifies a pair of matched nodes: node
│ │ │ partial_match[i, 0] of A is matched to node
│ │ │ partial_match[i, 1] of B. The array has shape (m, 2),
│ │ │ where m is not greater than the number of nodes, \(n\).
│ │ │ Each row of partial_match specifies a pair of matched nodes:
│ │ │ node partial_match[i, 0] of A is matched to node
│ │ │ partial_match[i, 1] of B. The array has shape (m, 2), where
│ │ │ m is not greater than the number of nodes, \(n\).
│ │ │
- rngint, RandomState, Generator or None, optional (default: None)
Accepts an integer as a seed for the random generator or a
│ │ │ RandomState or Generator object. If None (default), uses
│ │ │ -global numpy.random random state.
│ │ │ +global numpy.random random state.
│ │ │ - P02-D array, “barycenter”, or “randomized” (default: “barycenter”)
Initial position. Must be a doubly-stochastic matrix [3].
│ │ │ If the initial position is an array, it must be a doubly stochastic
│ │ │ matrix of size \(m' \times m'\) where \(m' = n - m\).
│ │ │ If "barycenter" (default), the initial position is the barycenter
│ │ │ of the Birkhoff polytope (the space of doubly stochastic matrices).
│ │ │ This is a \(m' \times m'\) matrix with all entries equal to
│ │ ├── ./usr/share/doc/python-scipy-doc/html/release.0.18.0.html
│ │ │ @@ -260,15 +260,15 @@
│ │ │
│ │ │
│ │ │
│ │ │ scipy.sparse improvements¶
│ │ │ The functions sum, max, mean, min, transpose, and reshape in
│ │ │ scipy.sparse have had their signatures augmented with additional arguments
│ │ │ and functionality so as to improve compatibility with analogously defined
│ │ │ -functions in numpy.
│ │ │ +functions in numpy.
│ │ │ Sparse matrices now have a count_nonzero method, which counts the number of
│ │ │ nonzero elements in the matrix. Unlike getnnz() and nnz property,
│ │ │ which return the number of stored entries (the length of the data attribute),
│ │ │ this method counts the actual number of non-zero entries in data.
│ │ │
│ │ │
│ │ │ scipy.optimize improvements¶
│ │ │ @@ -382,15 +382,15 @@
│ │ │ scipy.stats¶
│ │ │ stats.ks_2samp used to return nonsensical values if the input was
│ │ │ not real or contained nans. It now raises an exception for such inputs.
│ │ │ Several deprecated methods of scipy.stats distributions have been removed:
│ │ │ est_loc_scale, vecfunc, veccdf and vec_generic_moment.
│ │ │ Deprecated functions nanmean, nanstd and nanmedian have been removed
│ │ │ from scipy.stats. These functions were deprecated in scipy 0.15.0 in favor
│ │ │ -of their numpy equivalents.
│ │ │ +of their numpy equivalents.
│ │ │ A bug in the rvs() method of the distributions in scipy.stats has
│ │ │ been fixed. When arguments to rvs() were given that were shaped for
│ │ │ broadcasting, in many cases the returned random samples were not random.
│ │ │ A simple example of the problem is stats.norm.rvs(loc=np.zeros(10)).
│ │ │ Because of the bug, that call would return 10 identical values. The bug
│ │ │ only affected code that relied on the broadcasting of the shape, location
│ │ │ and scale parameters.
│ │ ├── ./usr/share/doc/python-scipy-doc/html/release.1.0.0.html
│ │ │ @@ -654,15 +654,15 @@
│ │ │ #7049: expm_multiply is excessively slow when called for intervals
#7050: Documenting _argcheck for rv_discrete
#7077: coo_matrix.tocsr() still slow
#7093: Wheels licensing
#7122: Sketching-based Matrix Computations
#7133: Discontinuity of a scipy special function
#7141: Improve documentation for Elliptic Integrals
#7181: A change in numpy.poly1d is causing the scipy tests to fail.
#7181: A change in numpy.poly1d is causing the scipy tests to fail.
#7220: String Formatting Issue in LinearOperator.__init__
#7239: Source tarball distribution
#7247: genlaguerre poly1d-object doesn’t respect ‘monic’ option at evaluation
#7248: BUG: regression in Legendre polynomials on master
#7316: dgels is missing
#7381: Krogh interpolation fails to produce derivatives for complex…
#7416: scipy.stats.kappa4(h,k) raise a ValueError for positive integer…
#8121: DOC: Add missing colons in docstrings
#8123: BLD: update Bento build config files for recent C99 changes.
#8124: Change to avoid use of fmod in scipy.signal.chebwin
#8126: Added examples for mode arg in geometric_transform
#8128: relax relative tolerance parameter in TestMinumumPhase.test_hilbert
#8129: ENH: special: use rational approximation for `digamma` on `[1,…
#8137: DOC Correct matrix width
#8141: MAINT: optimize: remove unused __main__ code in L-BSGS-B
#8141: MAINT: optimize: remove unused __main__ code in L-BSGS-B
#8147: BLD: update Bento build for removal of .npz scipy.special test…
#8148: Alias hanning as an explanatory function of hann
#8149: MAINT: special: small fixes for digamma
#8159: Update version classifiers
#8164: BUG: riccati solvers don’t catch ill-conditioned problems sufficiently…
#8168: DOC: release note for sparse resize methods
#8170: BUG: correctly pad netCDF files with null bytes
roots_sh_jacobi(n, p1, q1[, mu])
Gauss-Jacobi (shifted) quadrature.
The functions below, in turn, return the polynomial coefficients in
│ │ │ -orthopoly1d objects, which function similarly as numpy.poly1d.
│ │ │ +orthopoly1d objects, which function similarly as numpy.poly1d.
│ │ │ The orthopoly1d class also has an attribute weights, which returns
│ │ │ the roots, weights, and total weights for the appropriate form of Gaussian
│ │ │ quadrature. These are returned in an n x 3 array with roots in the first
│ │ │ column, weights in the second column, and total weights in the final column.
│ │ │ -Note that orthopoly1d objects are converted to poly1d when doing
│ │ │ +Note that orthopoly1d objects are converted to poly1d when doing
│ │ │ arithmetic, and lose information of the original orthogonal polynomial.
│ │ │
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/tutorial/arpack.html
│ │ │ @@ -177,15 +177,15 @@
│ │ │
│ │ │ \[\nu = \frac{1}{\lambda - \sigma}.\]
│ │ │
│ │ │
│ │ │ Examples¶
│ │ │ Imagine you’d like to find the smallest and largest eigenvalues and the
│ │ │ corresponding eigenvectors for a large matrix. ARPACK can handle many
│ │ │ -forms of input: dense matrices ,such as numpy.ndarray instances, sparse
│ │ │ +forms of input: dense matrices ,such as numpy.ndarray instances, sparse
│ │ │ matrices, such as scipy.sparse.csr_matrix, or a general linear operator
│ │ │ derived from scipy.sparse.linalg.LinearOperator. For this example, for
│ │ │ simplicity, we’ll construct a symmetric, positive-definite matrix.
│ │ │ >>> import numpy as np
│ │ │ >>> from scipy.linalg import eig, eigh
│ │ │ >>> from scipy.sparse.linalg import eigs, eigsh
│ │ │ >>> np.set_printoptions(suppress=True)
│ │ ├── ./usr/share/doc/python-scipy-doc/html/tutorial/general.html
│ │ │ @@ -222,15 +222,15 @@
│ │ │ SciPy sub-packages need to be imported separately, for example:
│ │ │ >>> from scipy import linalg, optimize
│ │ │
│ │ │
│ │ │ Because of their ubiquitousness, some of the functions in these
│ │ │ subpackages are also made available in the scipy namespace to ease
│ │ │ their use in interactive sessions and programs. In addition, many
│ │ │ -basic array functions from numpy are also available at the
│ │ │ +basic array functions from numpy are also available at the
│ │ │ top-level of the scipy package. Before looking at the
│ │ │ sub-packages individually, we will first look at some of these common
│ │ │ functions.
│ │ │
│ │ │
│ │ │ Finding Documentation¶
│ │ │ SciPy and NumPy have documentation versions in both HTML and PDF format
│ │ │ @@ -239,15 +239,15 @@
│ │ │ work-in-progress and some parts may be incomplete or sparse. As
│ │ │ we are a volunteer organization and depend on the community for
│ │ │ growth, your participation - everything from providing feedback to
│ │ │ improving the documentation and code - is welcome and actively
│ │ │ encouraged.
│ │ │ Python’s documentation strings are used in SciPy for on-line
│ │ │ documentation. There are two methods for reading them and
│ │ │ -getting help. One is Python’s command help in the pydoc
│ │ │ +getting help. One is Python’s command help in the pydoc
│ │ │ module. Entering this command with no arguments (i.e. >>> help )
│ │ │ launches an interactive help session that allows searching through the
│ │ │ keywords and modules available to all of Python. Secondly, running the command
│ │ │ help(obj) with an object as the argument displays that object’s calling
│ │ │ signature, and documentation string.
│ │ │ The pydoc method of help is sophisticated but uses a pager to display
│ │ │ the text. Sometimes this can interfere with the terminal within which you are
│ │ ├── ./usr/share/doc/python-scipy-doc/html/tutorial/integrate.html
│ │ │ @@ -416,15 +416,15 @@
│ │ │ by compilation of the function itself. Additionally we have a speedup
│ │ │ provided by the removal of function calls between C and Python in
│ │ │ quad. This method may provide a speed improvements of ~2x for
│ │ │ trivial functions such as sine but can produce a much more noticeable
│ │ │ improvements (10x+) for more complex functions. This feature then, is
│ │ │ geared towards a user with numerically intensive integrations willing
│ │ │ to write a little C to reduce computation time significantly.
│ │ │ -The approach can be used, for example, via ctypes in a few simple steps:
│ │ │ +The approach can be used, for example, via ctypes in a few simple steps:
│ │ │ 1.) Write an integrand function in C with the function signature
│ │ │ double f(int n, double *x, void *user_data), where x is an
│ │ │ array containing the point the function f is evaluated at, and user_data
│ │ │ to arbitrary additional data you want to provide.
│ │ │ /* testlib.c */
│ │ │ double f(int n, double *x, void *user_data) {
│ │ │ double c = *(double *)user_data;
│ │ │ @@ -436,16 +436,16 @@
│ │ │ with this as it is OS-dependent). The user must link any math libraries,
│ │ │ etc., used. On linux this looks like:
│ │ │ $ gcc -shared -fPIC -o testlib.so testlib.c
│ │ │
│ │ │
│ │ │ The output library will be referred to as testlib.so, but it may have a
│ │ │ different file extension. A library has now been created that can be loaded
│ │ │ -into Python with ctypes.
│ │ │ -3.) Load shared library into Python using ctypes and set restypes and
│ │ │ +into Python with ctypes.
│ │ │ +3.) Load shared library into Python using ctypes and set restypes and
│ │ │ argtypes - this allows SciPy to interpret the function correctly:
│ │ │ import os, ctypes
│ │ │ from scipy import integrate, LowLevelCallable
│ │ │
│ │ │ lib = ctypes.CDLL(os.path.abspath('testlib.so'))
│ │ │ lib.f.restype = ctypes.c_double
│ │ │ lib.f.argtypes = (ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_void_p)
│ │ ├── ./usr/share/doc/python-scipy-doc/html/tutorial/interpolate.html
│ │ │ @@ -525,20 +525,20 @@
│ │ │ It is important to note that 2-D interpolation should not
│ │ │ be used to find the spline representation of images. The algorithm
│ │ │ used is not amenable to large numbers of input points. The signal-processing
│ │ │ toolbox contains more appropriate algorithms for finding
│ │ │ the spline representation of an image. The 2-D
│ │ │ interpolation commands are intended for use when interpolating a 2-D
│ │ │ function as shown in the example that follows. This
│ │ │ -example uses the mgrid command in NumPy which is
│ │ │ +example uses the mgrid command in NumPy which is
│ │ │ useful for defining a “mesh-grid” in many dimensions. (See also the
│ │ │ -ogrid command if the full-mesh is not
│ │ │ +ogrid command if the full-mesh is not
│ │ │ needed). The number of output arguments and the number of dimensions
│ │ │ of each argument is determined by the number of indexing objects
│ │ │ -passed in mgrid.
│ │ │ +passed in mgrid.
│ │ │ >>> import numpy as np
│ │ │ >>> from scipy import interpolate
│ │ │ >>> import matplotlib.pyplot as plt
│ │ │
│ │ │
│ │ │ Define function over a sparse 20x20 grid
│ │ │ >>> x_edges, y_edges = np.mgrid[-1:1:21j, -1:1:21j]
│ │ ├── ./usr/share/doc/python-scipy-doc/html/tutorial/linalg.html
│ │ │ @@ -160,16 +160,16 @@
│ │ │ Therefore, unless you don’t want to add scipy as a dependency to
│ │ │ your numpy program, use scipy.linalg instead of numpy.linalg.
│ │ │
│ │ │
│ │ │ numpy.matrix vs 2-D numpy.ndarray¶
│ │ │ The classes that represent matrices, and basic operations, such as
│ │ │ matrix multiplications and transpose are a part of numpy.
│ │ │ -For convenience, we summarize the differences between numpy.matrix
│ │ │ -and numpy.ndarray here.
│ │ │ +For convenience, we summarize the differences between numpy.matrix
│ │ │ +and numpy.ndarray here.
│ │ │ numpy.matrix is matrix class that has a more convenient interface
│ │ │ than numpy.ndarray for matrix operations. This class supports, for
│ │ │ example, MATLAB-like creation syntax via the semicolon, has matrix
│ │ │ multiplication as default for the * operator, and contains I
│ │ │ and T members that serve as shortcuts for inverse and transpose:
│ │ │ >>> import numpy as np
│ │ │ >>> A = np.mat('[1 2;3 4]')
│ │ │ @@ -925,15 +925,15 @@
│ │ │ Create the inverse of a Pascal matrix.
Toeplitz
Create a Toeplitz matrix.
Van der Monde
Create a Van der Monde matrix.
│ │ │
│ │ │ For examples of the use of these functions, see their respective docstrings.
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-scipy-doc/html/tutorial/ndimage.html
│ │ │ @@ -140,15 +140,15 @@
│ │ │ Multidimensional image processing (scipy.ndimage)¶
│ │ │
│ │ │ Introduction¶
│ │ │ Image processing and analysis are generally seen as operations on
│ │ │ 2-D arrays of values. There are, however, a number of
│ │ │ fields where images of higher dimensionality must be analyzed. Good
│ │ │ examples of these are medical imaging and biological imaging.
│ │ │ -numpy is suited very well for this type of applications due to
│ │ │ +numpy is suited very well for this type of applications due to
│ │ │ its inherent multidimensional nature. The scipy.ndimage
│ │ │ packages provides a number of general image processing and analysis
│ │ │ functions that are designed to operate with arrays of arbitrary
│ │ │ dimensionality. The packages currently includes: functions for
│ │ │ linear and non-linear filtering, binary morphology, B-spline
│ │ │ interpolation, and object measurements.
│ │ │
│ │ │ @@ -163,15 +163,15 @@
│ │ │ result.
│ │ │ The type of arrays returned is dependent on the type of operation,
│ │ │ but it is, in most cases, equal to the type of the input. If,
│ │ │ however, the output argument is used, the type of the result is
│ │ │ equal to the type of the specified output argument. If no output
│ │ │ argument is given, it is still possible to specify what the result
│ │ │ of the output should be. This is done by simply assigning the
│ │ │ -desired numpy type object to the output argument. For example:
│ │ │ +desired numpy type object to the output argument. For example:
│ │ │ >>> from scipy.ndimage import correlate
│ │ │ >>> correlate(np.arange(10), [1, 2.5])
│ │ │ array([ 0, 2, 6, 9, 13, 16, 20, 23, 27, 30])
│ │ │ >>> correlate(np.arange(10), [1, 2.5], output=np.float64)
│ │ │ array([ 0. , 2.5, 6. , 9.5, 13. , 16.5, 20. , 23.5, 27. , 30.5])
│ │ │
│ │ │
│ │ │ @@ -590,15 +590,15 @@
│ │ │ To implement filter functions, generic functions can be used that
│ │ │ accept a callable object that implements the filtering operation. The
│ │ │ iteration over the input and output arrays is handled by these generic
│ │ │ functions, along with such details as the implementation of the
│ │ │ boundary conditions. Only a callable object implementing a callback
│ │ │ function that does the actual filtering work must be provided. The
│ │ │ callback function can also be written in C and passed using a
│ │ │ -PyCapsule (see Extending scipy.ndimage in C for more
│ │ │ +PyCapsule (see Extending scipy.ndimage in C for more
│ │ │ information).
│ │ │
│ │ │ The generic_filter1d function implements a generic
│ │ │ 1-D filter function, where the actual filtering
│ │ │ operation must be supplied as a python function (or other callable
│ │ │ object). The generic_filter1d function iterates over the
│ │ │ lines of an array and calls function at each line. The
│ │ │ @@ -808,15 +808,15 @@
│ │ │
│ │ │
│ │ │
│ │ │ Fourier domain filters¶
│ │ │ The functions described in this section perform filtering
│ │ │ operations in the Fourier domain. Thus, the input array of such a
│ │ │ function should be compatible with an inverse Fourier transform
│ │ │ -function, such as the functions from the numpy.fft module. We,
│ │ │ +function, such as the functions from the numpy.fft module. We,
│ │ │ therefore, have to deal with arrays that may be the result of a real
│ │ │ or a complex Fourier transform. In the case of a real Fourier
│ │ │ transform, only half of the of the symmetric complex transform is
│ │ │ stored. Additionally, it needs to be known what the length of the
│ │ │ axis was that was transformed by the real fft. The functions
│ │ │ described here provide a parameter n that, in the case of a real
│ │ │ transform, must be equal to the length of the real transform axis
│ │ │ @@ -1317,15 +1317,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ Segmentation and labeling¶
│ │ │ Segmentation is the process of separating objects of interest from
│ │ │ the background. The most simple approach is, probably, intensity
│ │ │ -thresholding, which is easily done with numpy functions:
│ │ │ +thresholding, which is easily done with numpy functions:
│ │ │ >>> a = np.array([[1,2,2,1,1,0],
│ │ │ ... [0,2,3,1,2,0],
│ │ │ ... [1,1,1,3,3,2],
│ │ │ ... [1,1,1,1,2,1]])
│ │ │ >>> np.where(a > 1, 1, 0)
│ │ │ array([[0, 1, 1, 0, 0, 0],
│ │ │ [0, 1, 1, 0, 1, 0],
│ │ │ @@ -1585,15 +1585,15 @@
│ │ │ defined by the elements that are larger than zero. If index is a
│ │ │ number or a sequence of numbers it gives the labels of the objects
│ │ │ that are measured. If index is a sequence, a list of the results is
│ │ │ returned. Functions that return more than one result return their
│ │ │ result as a tuple if index is a single number, or as a tuple of
│ │ │ lists if index is a sequence.
│ │ │
│ │ │ -The sum function calculates the sum of the elements of the
│ │ │ +
The sum function calculates the sum of the elements of the
│ │ │ object with label(s) given by index, using the labels array for
│ │ │ the object labels. If index is None, all elements with a
│ │ │ non-zero label value are treated as a single object. If label is
│ │ │ None, all elements of input are used in the calculation.
The mean function calculates the mean of the elements of the
│ │ │ object with label(s) given by index, using the labels array for
│ │ │ the object labels. If index is None, all elements with a
│ │ │ @@ -1778,22 +1778,22 @@
│ │ │ same role as they do in the python version, while output_rank and
│ │ │ input_rank provide the equivalents of len(output_coordinates)
│ │ │ and len(input_coordinates). The variable shift is passed
│ │ │ through user_data instead of
│ │ │ extra_arguments. Finally, the C callback function returns an integer
│ │ │ status, which is one upon success and zero otherwise.
│ │ │ The function py_transform wraps the callback function in a
│ │ │ -PyCapsule. The main steps are:
│ │ │ +PyCapsule. The main steps are:
│ │ │
│ │ │ -Initialize a PyCapsule. The first argument is a pointer to
│ │ │ +
Initialize a PyCapsule. The first argument is a pointer to
│ │ │ the callback function.
The second argument is the function signature, which must match exactly
│ │ │ the one expected by ndimage.
Above, we used scipy.LowLevelCallable to specify user_data
│ │ │ -that we generated with ctypes.
│ │ │ +that we generated with ctypes.
│ │ │ A different approach would be to supply the data in the capsule context,
│ │ │ that can be set by PyCapsule_SetContext and omit specifying
│ │ │ user_data in scipy.LowLevelCallable. However, in this approach we would
│ │ │ need to deal with allocation/freeing of the data — freeing the data
│ │ │ after the capsule has been destroyed can be done by specifying a non-NULL
│ │ │ callback function in the third argument of PyCapsule_New.
│ │ │ To generate a sequence of random variates, use the size keyword
│ │ │ argument:
│ │ │ >>> norm.rvs(size=3)
│ │ │ array([-0.35687759, 1.34347647, -0.11710531]) # random
│ │ │
│ │ │
│ │ │ Note that drawing random numbers relies on generators from
│ │ │ -numpy.random
│ │ │ +numpy.random
│ │ │ package. In the example above, the specific stream of
│ │ │ random numbers is not reproducible across runs. To achieve reproducibility,
│ │ │ you can explicitly seed a global variable
│ │ │ >>> np.random.seed(1234)
│ │ │
│ │ │
│ │ │ Relying on a global state is not recommended, though. A better way is to use
│ │ │ the random_state parameter, which accepts an instance of
│ │ │ -numpy.random.RandomState class, or an integer, which is then used to
│ │ │ +numpy.random.RandomState class, or an integer, which is then used to
│ │ │ seed an internal RandomState object:
│ │ │ >>> norm.rvs(size=5, random_state=1234)
│ │ │ array([ 0.47143516, -1.19097569, 1.43270697, -0.3126519 , -0.72058873])
│ │ │
│ │ │
│ │ │ Don’t think that norm.rvs(5) generates 5 variates:
│ │ │ >>> norm.rvs(5)